Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/arocc/src | repos/arocc/src/aro/Parser.zig | const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const assert = std.debug.assert;
const big = std.math.big;
const Compilation = @import("Compilation.zig");
const Source = @import("Source.zig");
const Tokenizer = @import("Tokenizer.zig");
const Preprocessor = @import("Preprocessor.zig");
const Tree = @import("Tree.zig");
const Token = Tree.Token;
const NumberPrefix = Token.NumberPrefix;
const NumberSuffix = Token.NumberSuffix;
const TokenIndex = Tree.TokenIndex;
const NodeIndex = Tree.NodeIndex;
const Type = @import("Type.zig");
const Diagnostics = @import("Diagnostics.zig");
const NodeList = std.ArrayList(NodeIndex);
const InitList = @import("InitList.zig");
const Attribute = @import("Attribute.zig");
const char_info = @import("char_info.zig");
const text_literal = @import("text_literal.zig");
const Value = @import("Value.zig");
const SymbolStack = @import("SymbolStack.zig");
const Symbol = SymbolStack.Symbol;
const record_layout = @import("record_layout.zig");
const StrInt = @import("StringInterner.zig");
const StringId = StrInt.StringId;
const Builtins = @import("Builtins.zig");
const Builtin = Builtins.Builtin;
const evalBuiltin = @import("Builtins/eval.zig").eval;
const target_util = @import("target.zig");
const Switch = struct {
default: ?TokenIndex = null,
ranges: std.ArrayList(Range),
ty: Type,
comp: *Compilation,
const Range = struct {
first: Value,
last: Value,
tok: TokenIndex,
};
fn add(self: *Switch, first: Value, last: Value, tok: TokenIndex) !?Range {
for (self.ranges.items) |range| {
if (last.compare(.gte, range.first, self.comp) and first.compare(.lte, range.last, self.comp)) {
return range; // They overlap.
}
}
try self.ranges.append(.{
.first = first,
.last = last,
.tok = tok,
});
return null;
}
};
const Label = union(enum) {
unresolved_goto: TokenIndex,
label: TokenIndex,
};
pub const Error = Compilation.Error || error{ParsingFailed};
/// An attribute that has been parsed but not yet validated in its context
const TentativeAttribute = struct {
attr: Attribute,
tok: TokenIndex,
};
/// How the parser handles const int decl references when it is expecting an integer
/// constant expression.
const ConstDeclFoldingMode = enum {
/// fold const decls as if they were literals
fold_const_decls,
/// fold const decls as if they were literals and issue GNU extension diagnostic
gnu_folding_extension,
/// fold const decls as if they were literals and issue VLA diagnostic
gnu_vla_folding_extension,
/// folding const decls is prohibited; return an unavailable value
no_const_decl_folding,
};
const Parser = @This();
// values from preprocessor
pp: *Preprocessor,
comp: *Compilation,
gpa: mem.Allocator,
tok_ids: []const Token.Id,
tok_i: TokenIndex = 0,
// values of the incomplete Tree
arena: Allocator,
nodes: Tree.Node.List = .{},
data: NodeList,
value_map: Tree.ValueMap,
// buffers used during compilation
syms: SymbolStack = .{},
strings: std.ArrayListAligned(u8, 4),
labels: std.ArrayList(Label),
list_buf: NodeList,
decl_buf: NodeList,
param_buf: std.ArrayList(Type.Func.Param),
enum_buf: std.ArrayList(Type.Enum.Field),
record_buf: std.ArrayList(Type.Record.Field),
attr_buf: std.MultiArrayList(TentativeAttribute) = .{},
attr_application_buf: std.ArrayListUnmanaged(Attribute) = .{},
field_attr_buf: std.ArrayList([]const Attribute),
/// type name -> variable name location for tentative definitions (top-level defs with thus-far-incomplete types)
/// e.g. `struct Foo bar;` where `struct Foo` is not defined yet.
/// The key is the StringId of `Foo` and the value is the TokenIndex of `bar`
/// Items are removed if the type is subsequently completed with a definition.
/// We only store the first tentative definition that uses a given type because this map is only used
/// for issuing an error message, and correcting the first error for a type will fix all of them for that type.
tentative_defs: std.AutoHashMapUnmanaged(StringId, TokenIndex) = .{},
// configuration and miscellaneous info
no_eval: bool = false,
in_macro: bool = false,
extension_suppressed: bool = false,
contains_address_of_label: bool = false,
label_count: u32 = 0,
const_decl_folding: ConstDeclFoldingMode = .fold_const_decls,
/// location of first computed goto in function currently being parsed
/// if a computed goto is used, the function must contain an
/// address-of-label expression (tracked with contains_address_of_label)
computed_goto_tok: ?TokenIndex = null,
/// __auto_type may only be used with a single declarator. Keep track of the name
/// so that it is not used in its own initializer.
auto_type_decl_name: StringId = .empty,
/// Various variables that are different for each function.
func: struct {
/// null if not in function, will always be plain func, var_args_func or old_style_func
ty: ?Type = null,
name: TokenIndex = 0,
ident: ?Result = null,
pretty_ident: ?Result = null,
} = .{},
/// Various variables that are different for each record.
record: struct {
// invalid means we're not parsing a record
kind: Token.Id = .invalid,
flexible_field: ?TokenIndex = null,
start: usize = 0,
field_attr_start: usize = 0,
fn addField(r: @This(), p: *Parser, name: StringId, tok: TokenIndex) Error!void {
var i = p.record_members.items.len;
while (i > r.start) {
i -= 1;
if (p.record_members.items[i].name == name) {
try p.errStr(.duplicate_member, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, p.record_members.items[i].tok);
break;
}
}
try p.record_members.append(p.gpa, .{ .name = name, .tok = tok });
}
fn addFieldsFromAnonymous(r: @This(), p: *Parser, ty: Type) Error!void {
for (ty.getRecord().?.fields) |f| {
if (f.isAnonymousRecord()) {
try r.addFieldsFromAnonymous(p, f.ty.canonicalize(.standard));
} else if (f.name_tok != 0) {
try r.addField(p, f.name, f.name_tok);
}
}
}
} = .{},
record_members: std.ArrayListUnmanaged(struct { tok: TokenIndex, name: StringId }) = .{},
@"switch": ?*Switch = null,
in_loop: bool = false,
pragma_pack: ?u8 = null,
string_ids: struct {
declspec_id: StringId,
main_id: StringId,
file: StringId,
jmp_buf: StringId,
sigjmp_buf: StringId,
ucontext_t: StringId,
},
/// Checks codepoint for various pedantic warnings
/// Returns true if diagnostic issued
fn checkIdentifierCodepointWarnings(comp: *Compilation, codepoint: u21, loc: Source.Location) Compilation.Error!bool {
assert(codepoint >= 0x80);
const err_start = comp.diagnostics.list.items.len;
if (!char_info.isC99IdChar(codepoint)) {
try comp.addDiagnostic(.{
.tag = .c99_compat,
.loc = loc,
}, &.{});
}
if (char_info.isInvisible(codepoint)) {
try comp.addDiagnostic(.{
.tag = .unicode_zero_width,
.loc = loc,
.extra = .{ .actual_codepoint = codepoint },
}, &.{});
}
if (char_info.homoglyph(codepoint)) |resembles| {
try comp.addDiagnostic(.{
.tag = .unicode_homoglyph,
.loc = loc,
.extra = .{ .codepoints = .{ .actual = codepoint, .resembles = resembles } },
}, &.{});
}
return comp.diagnostics.list.items.len != err_start;
}
/// Issues diagnostics for the current extended identifier token
/// Return value indicates whether the token should be considered an identifier
/// true means consider the token to actually be an identifier
/// false means it is not
fn validateExtendedIdentifier(p: *Parser) !bool {
assert(p.tok_ids[p.tok_i] == .extended_identifier);
const slice = p.tokSlice(p.tok_i);
const view = std.unicode.Utf8View.init(slice) catch {
try p.errTok(.invalid_utf8, p.tok_i);
return error.FatalError;
};
var it = view.iterator();
var valid_identifier = true;
var warned = false;
var len: usize = 0;
var invalid_char: u21 = undefined;
var loc = p.pp.tokens.items(.loc)[p.tok_i];
var normalized = true;
var last_canonical_class: char_info.CanonicalCombiningClass = .not_reordered;
const standard = p.comp.langopts.standard;
while (it.nextCodepoint()) |codepoint| {
defer {
len += 1;
loc.byte_offset += std.unicode.utf8CodepointSequenceLength(codepoint) catch unreachable;
}
if (codepoint == '$') {
warned = true;
if (p.comp.langopts.dollars_in_identifiers) try p.comp.addDiagnostic(.{
.tag = .dollar_in_identifier_extension,
.loc = loc,
}, &.{});
}
if (codepoint <= 0x7F) continue;
if (!valid_identifier) continue;
const allowed = standard.codepointAllowedInIdentifier(codepoint, len == 0);
if (!allowed) {
invalid_char = codepoint;
valid_identifier = false;
continue;
}
if (!warned) {
warned = try checkIdentifierCodepointWarnings(p.comp, codepoint, loc);
}
// Check NFC normalization.
if (!normalized) continue;
const canonical_class = char_info.getCanonicalClass(codepoint);
if (@intFromEnum(last_canonical_class) > @intFromEnum(canonical_class) and
canonical_class != .not_reordered)
{
normalized = false;
try p.errStr(.identifier_not_normalized, p.tok_i, slice);
continue;
}
if (char_info.isNormalized(codepoint) != .yes) {
normalized = false;
try p.errExtra(.identifier_not_normalized, p.tok_i, .{ .normalized = slice });
}
last_canonical_class = canonical_class;
}
if (!valid_identifier) {
if (len == 1) {
try p.errExtra(.unexpected_character, p.tok_i, .{ .actual_codepoint = invalid_char });
return false;
} else {
try p.errExtra(.invalid_identifier_start_char, p.tok_i, .{ .actual_codepoint = invalid_char });
}
}
return true;
}
fn eatIdentifier(p: *Parser) !?TokenIndex {
switch (p.tok_ids[p.tok_i]) {
.identifier => {},
.extended_identifier => {
if (!try p.validateExtendedIdentifier()) {
p.tok_i += 1;
return null;
}
},
else => return null,
}
p.tok_i += 1;
// Handle illegal '$' characters in identifiers
if (!p.comp.langopts.dollars_in_identifiers) {
if (p.tok_ids[p.tok_i] == .invalid and p.tokSlice(p.tok_i)[0] == '$') {
try p.err(.dollars_in_identifiers);
p.tok_i += 1;
return error.ParsingFailed;
}
}
return p.tok_i - 1;
}
fn expectIdentifier(p: *Parser) Error!TokenIndex {
const actual = p.tok_ids[p.tok_i];
if (actual != .identifier and actual != .extended_identifier) {
return p.errExpectedToken(.identifier, actual);
}
return (try p.eatIdentifier()) orelse error.ParsingFailed;
}
fn eatToken(p: *Parser, id: Token.Id) ?TokenIndex {
assert(id != .identifier and id != .extended_identifier); // use eatIdentifier
if (p.tok_ids[p.tok_i] == id) {
defer p.tok_i += 1;
return p.tok_i;
} else return null;
}
fn expectToken(p: *Parser, expected: Token.Id) Error!TokenIndex {
assert(expected != .identifier and expected != .extended_identifier); // use expectIdentifier
const actual = p.tok_ids[p.tok_i];
if (actual != expected) return p.errExpectedToken(expected, actual);
defer p.tok_i += 1;
return p.tok_i;
}
pub fn tokSlice(p: *Parser, tok: TokenIndex) []const u8 {
if (p.tok_ids[tok].lexeme()) |some| return some;
const loc = p.pp.tokens.items(.loc)[tok];
var tmp_tokenizer = Tokenizer{
.buf = p.comp.getSource(loc.id).buf,
.langopts = p.comp.langopts,
.index = loc.byte_offset,
.source = .generated,
};
const res = tmp_tokenizer.next();
return tmp_tokenizer.buf[res.start..res.end];
}
fn expectClosing(p: *Parser, opening: TokenIndex, id: Token.Id) Error!void {
_ = p.expectToken(id) catch |e| {
if (e == error.ParsingFailed) {
try p.errTok(switch (id) {
.r_paren => .to_match_paren,
.r_brace => .to_match_brace,
.r_bracket => .to_match_brace,
else => unreachable,
}, opening);
}
return e;
};
}
fn errOverflow(p: *Parser, op_tok: TokenIndex, res: Result) !void {
try p.errStr(.overflow, op_tok, try res.str(p));
}
fn errExpectedToken(p: *Parser, expected: Token.Id, actual: Token.Id) Error {
switch (actual) {
.invalid => try p.errExtra(.expected_invalid, p.tok_i, .{ .tok_id_expected = expected }),
.eof => try p.errExtra(.expected_eof, p.tok_i, .{ .tok_id_expected = expected }),
else => try p.errExtra(.expected_token, p.tok_i, .{ .tok_id = .{
.expected = expected,
.actual = actual,
} }),
}
return error.ParsingFailed;
}
pub fn errStr(p: *Parser, tag: Diagnostics.Tag, tok_i: TokenIndex, str: []const u8) Compilation.Error!void {
@branchHint(.cold);
return p.errExtra(tag, tok_i, .{ .str = str });
}
pub fn errExtra(p: *Parser, tag: Diagnostics.Tag, tok_i: TokenIndex, extra: Diagnostics.Message.Extra) Compilation.Error!void {
@branchHint(.cold);
const tok = p.pp.tokens.get(tok_i);
var loc = tok.loc;
if (tok_i != 0 and tok.id == .eof) {
// if the token is EOF, point at the end of the previous token instead
const prev = p.pp.tokens.get(tok_i - 1);
loc = prev.loc;
loc.byte_offset += @intCast(p.tokSlice(tok_i - 1).len);
}
try p.comp.addDiagnostic(.{
.tag = tag,
.loc = loc,
.extra = extra,
}, p.pp.expansionSlice(tok_i));
}
pub fn errTok(p: *Parser, tag: Diagnostics.Tag, tok_i: TokenIndex) Compilation.Error!void {
@branchHint(.cold);
return p.errExtra(tag, tok_i, .{ .none = {} });
}
pub fn err(p: *Parser, tag: Diagnostics.Tag) Compilation.Error!void {
@branchHint(.cold);
return p.errExtra(tag, p.tok_i, .{ .none = {} });
}
pub fn todo(p: *Parser, msg: []const u8) Error {
try p.errStr(.todo, p.tok_i, msg);
return error.ParsingFailed;
}
pub fn removeNull(p: *Parser, str: Value) !Value {
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
{
const bytes = p.comp.interner.get(str.ref()).bytes;
try p.strings.appendSlice(bytes[0 .. bytes.len - 1]);
}
return Value.intern(p.comp, .{ .bytes = p.strings.items[strings_top..] });
}
pub fn typeStr(p: *Parser, ty: Type) ![]const u8 {
if (@import("builtin").mode != .Debug) {
if (ty.is(.invalid)) {
return "Tried to render invalid type - this is an aro bug.";
}
}
if (Type.Builder.fromType(ty).str(p.comp.langopts)) |str| return str;
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
const mapper = p.comp.string_interner.getSlowTypeMapper();
try ty.print(mapper, p.comp.langopts, p.strings.writer());
return try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
}
pub fn typePairStr(p: *Parser, a: Type, b: Type) ![]const u8 {
return p.typePairStrExtra(a, " and ", b);
}
pub fn typePairStrExtra(p: *Parser, a: Type, msg: []const u8, b: Type) ![]const u8 {
if (@import("builtin").mode != .Debug) {
if (a.is(.invalid) or b.is(.invalid)) {
return "Tried to render invalid type - this is an aro bug.";
}
}
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
try p.strings.append('\'');
const mapper = p.comp.string_interner.getSlowTypeMapper();
try a.print(mapper, p.comp.langopts, p.strings.writer());
try p.strings.append('\'');
try p.strings.appendSlice(msg);
try p.strings.append('\'');
try b.print(mapper, p.comp.langopts, p.strings.writer());
try p.strings.append('\'');
return try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
}
pub fn valueChangedStr(p: *Parser, res: *Result, old_value: Value, int_ty: Type) ![]const u8 {
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
var w = p.strings.writer();
const type_pair_str = try p.typePairStrExtra(res.ty, " to ", int_ty);
try w.writeAll(type_pair_str);
try w.writeAll(" changes ");
if (res.val.isZero(p.comp)) try w.writeAll("non-zero ");
try w.writeAll("value from ");
try old_value.print(res.ty, p.comp, w);
try w.writeAll(" to ");
try res.val.print(int_ty, p.comp, w);
return try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
}
fn checkDeprecatedUnavailable(p: *Parser, ty: Type, usage_tok: TokenIndex, decl_tok: TokenIndex) !void {
if (ty.getAttribute(.@"error")) |@"error"| {
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
const w = p.strings.writer();
const msg_str = p.comp.interner.get(@"error".msg.ref()).bytes;
try w.print("call to '{s}' declared with attribute error: {}", .{
p.tokSlice(@"error".__name_tok), std.zig.fmtEscapes(msg_str),
});
const str = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
try p.errStr(.error_attribute, usage_tok, str);
}
if (ty.getAttribute(.warning)) |warning| {
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
const w = p.strings.writer();
const msg_str = p.comp.interner.get(warning.msg.ref()).bytes;
try w.print("call to '{s}' declared with attribute warning: {}", .{
p.tokSlice(warning.__name_tok), std.zig.fmtEscapes(msg_str),
});
const str = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
try p.errStr(.warning_attribute, usage_tok, str);
}
if (ty.getAttribute(.unavailable)) |unavailable| {
try p.errDeprecated(.unavailable, usage_tok, unavailable.msg);
try p.errStr(.unavailable_note, unavailable.__name_tok, p.tokSlice(decl_tok));
return error.ParsingFailed;
} else if (ty.getAttribute(.deprecated)) |deprecated| {
try p.errDeprecated(.deprecated_declarations, usage_tok, deprecated.msg);
try p.errStr(.deprecated_note, deprecated.__name_tok, p.tokSlice(decl_tok));
}
}
fn errDeprecated(p: *Parser, tag: Diagnostics.Tag, tok_i: TokenIndex, msg: ?Value) Compilation.Error!void {
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
const w = p.strings.writer();
try w.print("'{s}' is ", .{p.tokSlice(tok_i)});
const reason: []const u8 = switch (tag) {
.unavailable => "unavailable",
.deprecated_declarations => "deprecated",
else => unreachable,
};
try w.writeAll(reason);
if (msg) |m| {
const str = p.comp.interner.get(m.ref()).bytes;
try w.print(": {}", .{std.zig.fmtEscapes(str)});
}
const str = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
return p.errStr(tag, tok_i, str);
}
fn addNode(p: *Parser, node: Tree.Node) Allocator.Error!NodeIndex {
if (p.in_macro) return .none;
const res = p.nodes.len;
try p.nodes.append(p.gpa, node);
return @enumFromInt(res);
}
fn addList(p: *Parser, nodes: []const NodeIndex) Allocator.Error!Tree.Node.Range {
if (p.in_macro) return Tree.Node.Range{ .start = 0, .end = 0 };
const start: u32 = @intCast(p.data.items.len);
try p.data.appendSlice(nodes);
const end: u32 = @intCast(p.data.items.len);
return Tree.Node.Range{ .start = start, .end = end };
}
fn findLabel(p: *Parser, name: []const u8) ?TokenIndex {
for (p.labels.items) |item| {
switch (item) {
.label => |l| if (mem.eql(u8, p.tokSlice(l), name)) return l,
.unresolved_goto => {},
}
}
return null;
}
fn nodeIs(p: *Parser, node: NodeIndex, tag: Tree.Tag) bool {
return p.getNode(node, tag) != null;
}
pub fn getDecayedStringLiteral(p: *Parser, node: NodeIndex) ?Value {
const cast_node = p.getNode(node, .implicit_cast) orelse return null;
const data = p.nodes.items(.data)[@intFromEnum(cast_node)];
if (data.cast.kind != .array_to_pointer) return null;
const literal_node = p.getNode(data.cast.operand, .string_literal_expr) orelse return null;
return p.value_map.get(literal_node);
}
fn getNode(p: *Parser, node: NodeIndex, tag: Tree.Tag) ?NodeIndex {
var cur = node;
const tags = p.nodes.items(.tag);
const data = p.nodes.items(.data);
while (true) {
const cur_tag = tags[@intFromEnum(cur)];
if (cur_tag == .paren_expr) {
cur = data[@intFromEnum(cur)].un;
} else if (cur_tag == tag) {
return cur;
} else {
return null;
}
}
}
fn nodeIsCompoundLiteral(p: *Parser, node: NodeIndex) bool {
var cur = node;
const tags = p.nodes.items(.tag);
const data = p.nodes.items(.data);
while (true) {
switch (tags[@intFromEnum(cur)]) {
.paren_expr => cur = data[@intFromEnum(cur)].un,
.compound_literal_expr,
.static_compound_literal_expr,
.thread_local_compound_literal_expr,
.static_thread_local_compound_literal_expr,
=> return true,
else => return false,
}
}
}
fn tmpTree(p: *Parser) Tree {
return .{
.nodes = p.nodes.slice(),
.data = p.data.items,
.value_map = p.value_map,
.comp = p.comp,
.arena = undefined,
.generated = undefined,
.tokens = undefined,
.root_decls = undefined,
};
}
fn pragma(p: *Parser) Compilation.Error!bool {
var found_pragma = false;
while (p.eatToken(.keyword_pragma)) |_| {
found_pragma = true;
const name_tok = p.tok_i;
const name = p.tokSlice(name_tok);
const end_idx = mem.indexOfScalarPos(Token.Id, p.tok_ids, p.tok_i, .nl).?;
const pragma_len = @as(TokenIndex, @intCast(end_idx)) - p.tok_i;
defer p.tok_i += pragma_len + 1; // skip past .nl as well
if (p.comp.getPragma(name)) |prag| {
try prag.parserCB(p, p.tok_i);
}
}
return found_pragma;
}
/// Issue errors for top-level definitions whose type was never completed.
fn diagnoseIncompleteDefinitions(p: *Parser) !void {
@branchHint(.cold);
const node_slices = p.nodes.slice();
const tags = node_slices.items(.tag);
const tys = node_slices.items(.ty);
const data = node_slices.items(.data);
for (p.decl_buf.items) |decl_node| {
const idx = @intFromEnum(decl_node);
switch (tags[idx]) {
.struct_forward_decl, .union_forward_decl, .enum_forward_decl => {},
else => continue,
}
const ty = tys[idx];
const decl_type_name = if (ty.getRecord()) |rec|
rec.name
else if (ty.get(.@"enum")) |en|
en.data.@"enum".name
else
unreachable;
const tentative_def_tok = p.tentative_defs.get(decl_type_name) orelse continue;
const type_str = try p.typeStr(ty);
try p.errStr(.tentative_definition_incomplete, tentative_def_tok, type_str);
try p.errStr(.forward_declaration_here, data[idx].decl_ref, type_str);
}
}
/// root : (decl | assembly ';' | staticAssert)*
pub fn parse(pp: *Preprocessor) Compilation.Error!Tree {
assert(pp.linemarkers == .none);
pp.comp.pragmaEvent(.before_parse);
var arena = std.heap.ArenaAllocator.init(pp.comp.gpa);
errdefer arena.deinit();
var p = Parser{
.pp = pp,
.comp = pp.comp,
.gpa = pp.comp.gpa,
.arena = arena.allocator(),
.tok_ids = pp.tokens.items(.id),
.strings = std.ArrayListAligned(u8, 4).init(pp.comp.gpa),
.value_map = Tree.ValueMap.init(pp.comp.gpa),
.data = NodeList.init(pp.comp.gpa),
.labels = std.ArrayList(Label).init(pp.comp.gpa),
.list_buf = NodeList.init(pp.comp.gpa),
.decl_buf = NodeList.init(pp.comp.gpa),
.param_buf = std.ArrayList(Type.Func.Param).init(pp.comp.gpa),
.enum_buf = std.ArrayList(Type.Enum.Field).init(pp.comp.gpa),
.record_buf = std.ArrayList(Type.Record.Field).init(pp.comp.gpa),
.field_attr_buf = std.ArrayList([]const Attribute).init(pp.comp.gpa),
.string_ids = .{
.declspec_id = try StrInt.intern(pp.comp, "__declspec"),
.main_id = try StrInt.intern(pp.comp, "main"),
.file = try StrInt.intern(pp.comp, "FILE"),
.jmp_buf = try StrInt.intern(pp.comp, "jmp_buf"),
.sigjmp_buf = try StrInt.intern(pp.comp, "sigjmp_buf"),
.ucontext_t = try StrInt.intern(pp.comp, "ucontext_t"),
},
};
errdefer {
p.nodes.deinit(pp.comp.gpa);
p.value_map.deinit();
}
defer {
p.data.deinit();
p.labels.deinit();
p.strings.deinit();
p.syms.deinit(pp.comp.gpa);
p.list_buf.deinit();
p.decl_buf.deinit();
p.param_buf.deinit();
p.enum_buf.deinit();
p.record_buf.deinit();
p.record_members.deinit(pp.comp.gpa);
p.attr_buf.deinit(pp.comp.gpa);
p.attr_application_buf.deinit(pp.comp.gpa);
p.tentative_defs.deinit(pp.comp.gpa);
assert(p.field_attr_buf.items.len == 0);
p.field_attr_buf.deinit();
}
try p.syms.pushScope(&p);
defer p.syms.popScope();
// NodeIndex 0 must be invalid
_ = try p.addNode(.{ .tag = .invalid, .ty = undefined, .data = undefined, .loc = undefined });
{
if (p.comp.langopts.hasChar8_T()) {
try p.syms.defineTypedef(&p, try StrInt.intern(p.comp, "char8_t"), .{ .specifier = .uchar }, 0, .none);
}
try p.syms.defineTypedef(&p, try StrInt.intern(p.comp, "__int128_t"), .{ .specifier = .int128 }, 0, .none);
try p.syms.defineTypedef(&p, try StrInt.intern(p.comp, "__uint128_t"), .{ .specifier = .uint128 }, 0, .none);
const elem_ty = try p.arena.create(Type);
elem_ty.* = .{ .specifier = .char };
try p.syms.defineTypedef(&p, try StrInt.intern(p.comp, "__builtin_ms_va_list"), .{
.specifier = .pointer,
.data = .{ .sub_type = elem_ty },
}, 0, .none);
const ty = &pp.comp.types.va_list;
try p.syms.defineTypedef(&p, try StrInt.intern(p.comp, "__builtin_va_list"), ty.*, 0, .none);
if (ty.isArray()) ty.decayArray();
try p.syms.defineTypedef(&p, try StrInt.intern(p.comp, "__NSConstantString"), pp.comp.types.ns_constant_string.ty, 0, .none);
if (p.comp.float80Type()) |float80_ty| {
try p.syms.defineTypedef(&p, try StrInt.intern(p.comp, "__float80"), float80_ty, 0, .none);
}
}
while (p.eatToken(.eof) == null) {
if (try p.pragma()) continue;
if (try p.parseOrNextDecl(staticAssert)) continue;
if (try p.parseOrNextDecl(decl)) continue;
if (p.eatToken(.keyword_extension)) |_| {
const saved_extension = p.extension_suppressed;
defer p.extension_suppressed = saved_extension;
p.extension_suppressed = true;
if (try p.parseOrNextDecl(decl)) continue;
switch (p.tok_ids[p.tok_i]) {
.semicolon => p.tok_i += 1,
.keyword_static_assert,
.keyword_c23_static_assert,
.keyword_pragma,
.keyword_extension,
.keyword_asm,
.keyword_asm1,
.keyword_asm2,
=> {},
else => try p.err(.expected_external_decl),
}
continue;
}
if (p.assembly(.global) catch |er| switch (er) {
error.ParsingFailed => {
p.nextExternDecl();
continue;
},
else => |e| return e,
}) |node| {
try p.decl_buf.append(node);
continue;
}
if (p.eatToken(.semicolon)) |tok| {
try p.errTok(.extra_semi, tok);
continue;
}
try p.err(.expected_external_decl);
p.tok_i += 1;
}
if (p.tentative_defs.count() > 0) {
try p.diagnoseIncompleteDefinitions();
}
const root_decls = try p.decl_buf.toOwnedSlice();
errdefer pp.comp.gpa.free(root_decls);
if (root_decls.len == 0) {
try p.errTok(.empty_translation_unit, p.tok_i - 1);
}
pp.comp.pragmaEvent(.after_parse);
const data = try p.data.toOwnedSlice();
errdefer pp.comp.gpa.free(data);
return Tree{
.comp = pp.comp,
.tokens = pp.tokens.slice(),
.arena = arena,
.generated = pp.comp.generated_buf.items,
.nodes = p.nodes.toOwnedSlice(),
.data = data,
.root_decls = root_decls,
.value_map = p.value_map,
};
}
fn skipToPragmaSentinel(p: *Parser) void {
while (true) : (p.tok_i += 1) {
if (p.tok_ids[p.tok_i] == .nl) return;
if (p.tok_ids[p.tok_i] == .eof) {
p.tok_i -= 1;
return;
}
}
}
fn parseOrNextDecl(p: *Parser, comptime func: fn (*Parser) Error!bool) Compilation.Error!bool {
return func(p) catch |er| switch (er) {
error.ParsingFailed => {
p.nextExternDecl();
return true;
},
else => |e| return e,
};
}
fn nextExternDecl(p: *Parser) void {
var parens: u32 = 0;
while (true) : (p.tok_i += 1) {
switch (p.tok_ids[p.tok_i]) {
.l_paren, .l_brace, .l_bracket => parens += 1,
.r_paren, .r_brace, .r_bracket => if (parens != 0) {
parens -= 1;
},
.keyword_typedef,
.keyword_extern,
.keyword_static,
.keyword_auto,
.keyword_register,
.keyword_thread_local,
.keyword_c23_thread_local,
.keyword_inline,
.keyword_inline1,
.keyword_inline2,
.keyword_noreturn,
.keyword_void,
.keyword_bool,
.keyword_c23_bool,
.keyword_char,
.keyword_short,
.keyword_int,
.keyword_long,
.keyword_signed,
.keyword_signed1,
.keyword_signed2,
.keyword_unsigned,
.keyword_float,
.keyword_double,
.keyword_complex,
.keyword_atomic,
.keyword_enum,
.keyword_struct,
.keyword_union,
.keyword_alignas,
.keyword_c23_alignas,
.identifier,
.extended_identifier,
.keyword_typeof,
.keyword_typeof1,
.keyword_typeof2,
.keyword_typeof_unqual,
.keyword_extension,
.keyword_bit_int,
=> if (parens == 0) return,
.keyword_pragma => p.skipToPragmaSentinel(),
.eof => return,
.semicolon => if (parens == 0) {
p.tok_i += 1;
return;
},
else => {},
}
}
}
fn skipTo(p: *Parser, id: Token.Id) void {
var parens: u32 = 0;
while (true) : (p.tok_i += 1) {
if (p.tok_ids[p.tok_i] == id and parens == 0) {
p.tok_i += 1;
return;
}
switch (p.tok_ids[p.tok_i]) {
.l_paren, .l_brace, .l_bracket => parens += 1,
.r_paren, .r_brace, .r_bracket => if (parens != 0) {
parens -= 1;
},
.keyword_pragma => p.skipToPragmaSentinel(),
.eof => return,
else => {},
}
}
}
/// Called after a typedef is defined
fn typedefDefined(p: *Parser, name: StringId, ty: Type) void {
if (name == p.string_ids.file) {
p.comp.types.file = ty;
} else if (name == p.string_ids.jmp_buf) {
p.comp.types.jmp_buf = ty;
} else if (name == p.string_ids.sigjmp_buf) {
p.comp.types.sigjmp_buf = ty;
} else if (name == p.string_ids.ucontext_t) {
p.comp.types.ucontext_t = ty;
}
}
// ====== declarations ======
/// decl
/// : declSpec (initDeclarator ( ',' initDeclarator)*)? ';'
/// | declSpec declarator decl* compoundStmt
fn decl(p: *Parser) Error!bool {
_ = try p.pragma();
const first_tok = p.tok_i;
const attr_buf_top = p.attr_buf.len;
defer p.attr_buf.len = attr_buf_top;
try p.attributeSpecifier();
var decl_spec = if (try p.declSpec()) |some| some else blk: {
if (p.func.ty != null) {
p.tok_i = first_tok;
return false;
}
switch (p.tok_ids[first_tok]) {
.asterisk, .l_paren, .identifier, .extended_identifier => {},
else => if (p.tok_i != first_tok) {
try p.err(.expected_ident_or_l_paren);
return error.ParsingFailed;
} else return false,
}
var spec: Type.Builder = .{};
break :blk DeclSpec{ .ty = try spec.finish(p) };
};
if (decl_spec.noreturn) |tok| {
const attr = Attribute{ .tag = .noreturn, .args = .{ .noreturn = .{} }, .syntax = .keyword };
try p.attr_buf.append(p.gpa, .{ .attr = attr, .tok = tok });
}
var init_d = (try p.initDeclarator(&decl_spec, attr_buf_top)) orelse {
_ = try p.expectToken(.semicolon);
if (decl_spec.ty.is(.@"enum") or
(decl_spec.ty.isRecord() and !decl_spec.ty.isAnonymousRecord(p.comp) and
!decl_spec.ty.isTypeof())) // we follow GCC and clang's behavior here
{
const specifier = decl_spec.ty.canonicalize(.standard).specifier;
const attrs = p.attr_buf.items(.attr)[attr_buf_top..];
const toks = p.attr_buf.items(.tok)[attr_buf_top..];
for (attrs, toks) |attr, tok| {
try p.errExtra(.ignored_record_attr, tok, .{
.ignored_record_attr = .{ .tag = attr.tag, .specifier = switch (specifier) {
.@"enum" => .@"enum",
.@"struct" => .@"struct",
.@"union" => .@"union",
else => unreachable,
} },
});
}
return true;
}
try p.errTok(.missing_declaration, first_tok);
return true;
};
// Check for function definition.
if (init_d.d.func_declarator != null and init_d.initializer.node == .none and init_d.d.ty.isFunc()) fn_def: {
if (decl_spec.auto_type) |tok_i| {
try p.errStr(.auto_type_not_allowed, tok_i, "function return type");
return error.ParsingFailed;
}
switch (p.tok_ids[p.tok_i]) {
.comma, .semicolon => break :fn_def,
.l_brace => {},
else => if (init_d.d.old_style_func == null) {
try p.err(.expected_fn_body);
return true;
},
}
if (p.func.ty != null) try p.err(.func_not_in_root);
const node = try p.addNode(undefined); // reserve space
const interned_declarator_name = try StrInt.intern(p.comp, p.tokSlice(init_d.d.name));
try p.syms.defineSymbol(p, interned_declarator_name, init_d.d.ty, init_d.d.name, node, .{}, false);
const func = p.func;
p.func = .{
.ty = init_d.d.ty,
.name = init_d.d.name,
};
if (interned_declarator_name == p.string_ids.main_id and !init_d.d.ty.returnType().is(.int)) {
try p.errTok(.main_return_type, init_d.d.name);
}
defer p.func = func;
try p.syms.pushScope(p);
defer p.syms.popScope();
// Collect old style parameter declarations.
if (init_d.d.old_style_func != null) {
const attrs = init_d.d.ty.getAttributes();
var base_ty = if (init_d.d.ty.specifier == .attributed) init_d.d.ty.data.attributed.base else init_d.d.ty;
base_ty.specifier = .func;
init_d.d.ty = try base_ty.withAttributes(p.arena, attrs);
const param_buf_top = p.param_buf.items.len;
defer p.param_buf.items.len = param_buf_top;
param_loop: while (true) {
const param_decl_spec = (try p.declSpec()) orelse break;
if (p.eatToken(.semicolon)) |semi| {
try p.errTok(.missing_declaration, semi);
continue :param_loop;
}
while (true) {
const attr_buf_top_declarator = p.attr_buf.len;
defer p.attr_buf.len = attr_buf_top_declarator;
var d = (try p.declarator(param_decl_spec.ty, .param)) orelse {
try p.errTok(.missing_declaration, first_tok);
_ = try p.expectToken(.semicolon);
continue :param_loop;
};
try p.attributeSpecifier();
if (d.ty.hasIncompleteSize() and !d.ty.is(.void)) try p.errStr(.parameter_incomplete_ty, d.name, try p.typeStr(d.ty));
if (d.ty.isFunc()) {
// Params declared as functions are converted to function pointers.
const elem_ty = try p.arena.create(Type);
elem_ty.* = d.ty;
d.ty = Type{
.specifier = .pointer,
.data = .{ .sub_type = elem_ty },
};
} else if (d.ty.isArray()) {
// params declared as arrays are converted to pointers
d.ty.decayArray();
} else if (d.ty.is(.void)) {
try p.errTok(.invalid_void_param, d.name);
}
// find and correct parameter types
// TODO check for missing declarations and redefinitions
const name_str = p.tokSlice(d.name);
const interned_name = try StrInt.intern(p.comp, name_str);
for (init_d.d.ty.params()) |*param| {
if (param.name == interned_name) {
param.ty = d.ty;
break;
}
} else {
try p.errStr(.parameter_missing, d.name, name_str);
}
d.ty = try Attribute.applyParameterAttributes(p, d.ty, attr_buf_top_declarator, .alignas_on_param);
// bypass redefinition check to avoid duplicate errors
try p.syms.define(p.gpa, .{
.kind = .def,
.name = interned_name,
.tok = d.name,
.ty = d.ty,
.val = .{},
});
if (p.eatToken(.comma) == null) break;
}
_ = try p.expectToken(.semicolon);
}
} else {
for (init_d.d.ty.params()) |param| {
if (param.ty.hasUnboundVLA()) try p.errTok(.unbound_vla, param.name_tok);
if (param.ty.hasIncompleteSize() and !param.ty.is(.void) and param.ty.specifier != .invalid) try p.errStr(.parameter_incomplete_ty, param.name_tok, try p.typeStr(param.ty));
if (param.name == .empty) {
try p.errTok(.omitting_parameter_name, param.name_tok);
continue;
}
// bypass redefinition check to avoid duplicate errors
try p.syms.define(p.gpa, .{
.kind = .def,
.name = param.name,
.tok = param.name_tok,
.ty = param.ty,
.val = .{},
});
}
}
const body = (try p.compoundStmt(true, null)) orelse {
assert(init_d.d.old_style_func != null);
try p.err(.expected_fn_body);
return true;
};
p.nodes.set(@intFromEnum(node), .{
.ty = init_d.d.ty,
.tag = try decl_spec.validateFnDef(p),
.data = .{ .decl = .{ .name = init_d.d.name, .node = body } },
.loc = @enumFromInt(init_d.d.name),
});
try p.decl_buf.append(node);
// check gotos
if (func.ty == null) {
for (p.labels.items) |item| {
if (item == .unresolved_goto)
try p.errStr(.undeclared_label, item.unresolved_goto, p.tokSlice(item.unresolved_goto));
}
if (p.computed_goto_tok) |goto_tok| {
if (!p.contains_address_of_label) try p.errTok(.invalid_computed_goto, goto_tok);
}
p.labels.items.len = 0;
p.label_count = 0;
p.contains_address_of_label = false;
p.computed_goto_tok = null;
}
return true;
}
// Declare all variable/typedef declarators.
var warned_auto = false;
while (true) {
if (init_d.d.old_style_func) |tok_i| try p.errTok(.invalid_old_style_params, tok_i);
const tag = try decl_spec.validate(p, &init_d.d.ty, init_d.initializer.node != .none);
const tok = switch (decl_spec.storage_class) {
.auto, .@"extern", .register, .static, .typedef => |tok| tok,
.none => init_d.d.name,
};
const node = try p.addNode(.{
.ty = init_d.d.ty,
.tag = tag,
.data = .{
.decl = .{ .name = init_d.d.name, .node = init_d.initializer.node },
},
.loc = @enumFromInt(tok),
});
try p.decl_buf.append(node);
const interned_name = try StrInt.intern(p.comp, p.tokSlice(init_d.d.name));
if (decl_spec.storage_class == .typedef) {
try p.syms.defineTypedef(p, interned_name, init_d.d.ty, init_d.d.name, node);
p.typedefDefined(interned_name, init_d.d.ty);
} else if (init_d.initializer.node != .none or
(p.func.ty != null and decl_spec.storage_class != .@"extern"))
{
// TODO validate global variable/constexpr initializer comptime known
try p.syms.defineSymbol(
p,
interned_name,
init_d.d.ty,
init_d.d.name,
node,
if (init_d.d.ty.isConst() or decl_spec.constexpr != null) init_d.initializer.val else .{},
decl_spec.constexpr != null,
);
} else {
try p.syms.declareSymbol(p, interned_name, init_d.d.ty, init_d.d.name, node);
}
if (p.eatToken(.comma) == null) break;
if (!warned_auto) {
if (decl_spec.auto_type) |tok_i| {
try p.errTok(.auto_type_requires_single_declarator, tok_i);
warned_auto = true;
}
if (p.comp.langopts.standard.atLeast(.c23) and decl_spec.storage_class == .auto) {
try p.errTok(.c23_auto_single_declarator, decl_spec.storage_class.auto);
warned_auto = true;
}
}
init_d = (try p.initDeclarator(&decl_spec, attr_buf_top)) orelse {
try p.err(.expected_ident_or_l_paren);
continue;
};
}
_ = try p.expectToken(.semicolon);
return true;
}
fn staticAssertMessage(p: *Parser, cond_node: NodeIndex, message: Result) !?[]const u8 {
const cond_tag = p.nodes.items(.tag)[@intFromEnum(cond_node)];
if (cond_tag != .builtin_types_compatible_p and message.node == .none) return null;
var buf = std.ArrayList(u8).init(p.gpa);
defer buf.deinit();
if (cond_tag == .builtin_types_compatible_p) {
const mapper = p.comp.string_interner.getSlowTypeMapper();
const data = p.nodes.items(.data)[@intFromEnum(cond_node)].bin;
try buf.appendSlice("'__builtin_types_compatible_p(");
const lhs_ty = p.nodes.items(.ty)[@intFromEnum(data.lhs)];
try lhs_ty.print(mapper, p.comp.langopts, buf.writer());
try buf.appendSlice(", ");
const rhs_ty = p.nodes.items(.ty)[@intFromEnum(data.rhs)];
try rhs_ty.print(mapper, p.comp.langopts, buf.writer());
try buf.appendSlice(")'");
}
if (message.node != .none) {
assert(p.nodes.items(.tag)[@intFromEnum(message.node)] == .string_literal_expr);
if (buf.items.len > 0) {
try buf.append(' ');
}
const bytes = p.comp.interner.get(message.val.ref()).bytes;
try buf.ensureUnusedCapacity(bytes.len);
try Value.printString(bytes, message.ty, p.comp, buf.writer());
}
return try p.comp.diagnostics.arena.allocator().dupe(u8, buf.items);
}
/// staticAssert
/// : keyword_static_assert '(' integerConstExpr (',' STRING_LITERAL)? ')' ';'
/// | keyword_c23_static_assert '(' integerConstExpr (',' STRING_LITERAL)? ')' ';'
fn staticAssert(p: *Parser) Error!bool {
const static_assert = p.eatToken(.keyword_static_assert) orelse p.eatToken(.keyword_c23_static_assert) orelse return false;
const l_paren = try p.expectToken(.l_paren);
const res_token = p.tok_i;
var res = try p.constExpr(.gnu_folding_extension);
const res_node = res.node;
const str = if (p.eatToken(.comma) != null)
switch (p.tok_ids[p.tok_i]) {
.string_literal,
.string_literal_utf_16,
.string_literal_utf_8,
.string_literal_utf_32,
.string_literal_wide,
.unterminated_string_literal,
=> try p.stringLiteral(),
else => {
try p.err(.expected_str_literal);
return error.ParsingFailed;
},
}
else
Result{};
try p.expectClosing(l_paren, .r_paren);
_ = try p.expectToken(.semicolon);
if (str.node == .none) {
try p.errTok(.static_assert_missing_message, static_assert);
try p.errStr(.pre_c23_compat, static_assert, "'_Static_assert' with no message");
}
// Array will never be zero; a value of zero for a pointer is a null pointer constant
if ((res.ty.isArray() or res.ty.isPtr()) and !res.val.isZero(p.comp)) {
const err_start = p.comp.diagnostics.list.items.len;
try p.errTok(.const_decl_folded, res_token);
if (res.ty.isPtr() and err_start != p.comp.diagnostics.list.items.len) {
// Don't show the note if the .const_decl_folded diagnostic was not added
try p.errTok(.constant_expression_conversion_not_allowed, res_token);
}
}
try res.boolCast(p, .{ .specifier = .bool }, res_token);
if (res.val.opt_ref == .none) {
if (res.ty.specifier != .invalid) {
try p.errTok(.static_assert_not_constant, res_token);
}
} else {
if (!res.val.toBool(p.comp)) {
if (try p.staticAssertMessage(res_node, str)) |message| {
try p.errStr(.static_assert_failure_message, static_assert, message);
} else {
try p.errTok(.static_assert_failure, static_assert);
}
}
}
const node = try p.addNode(.{
.tag = .static_assert,
.data = .{ .bin = .{
.lhs = res.node,
.rhs = str.node,
} },
.loc = @enumFromInt(static_assert),
});
try p.decl_buf.append(node);
return true;
}
pub const DeclSpec = struct {
storage_class: union(enum) {
auto: TokenIndex,
@"extern": TokenIndex,
register: TokenIndex,
static: TokenIndex,
typedef: TokenIndex,
none,
} = .none,
thread_local: ?TokenIndex = null,
constexpr: ?TokenIndex = null,
@"inline": ?TokenIndex = null,
noreturn: ?TokenIndex = null,
auto_type: ?TokenIndex = null,
ty: Type,
fn validateParam(d: DeclSpec, p: *Parser, ty: *Type) Error!void {
switch (d.storage_class) {
.none => {},
.register => ty.qual.register = true,
.auto, .@"extern", .static, .typedef => |tok_i| try p.errTok(.invalid_storage_on_param, tok_i),
}
if (d.thread_local) |tok_i| try p.errTok(.threadlocal_non_var, tok_i);
if (d.@"inline") |tok_i| try p.errStr(.func_spec_non_func, tok_i, "inline");
if (d.noreturn) |tok_i| try p.errStr(.func_spec_non_func, tok_i, "_Noreturn");
if (d.constexpr) |tok_i| try p.errTok(.invalid_storage_on_param, tok_i);
if (d.auto_type) |tok_i| {
try p.errStr(.auto_type_not_allowed, tok_i, "function prototype");
ty.* = Type.invalid;
}
}
fn validateFnDef(d: DeclSpec, p: *Parser) Error!Tree.Tag {
switch (d.storage_class) {
.none, .@"extern", .static => {},
.auto, .register, .typedef => |tok_i| try p.errTok(.illegal_storage_on_func, tok_i),
}
if (d.thread_local) |tok_i| try p.errTok(.threadlocal_non_var, tok_i);
if (d.constexpr) |tok_i| try p.errTok(.illegal_storage_on_func, tok_i);
const is_static = d.storage_class == .static;
const is_inline = d.@"inline" != null;
if (is_static) {
if (is_inline) return .inline_static_fn_def;
return .static_fn_def;
} else {
if (is_inline) return .inline_fn_def;
return .fn_def;
}
}
fn validate(d: DeclSpec, p: *Parser, ty: *Type, has_init: bool) Error!Tree.Tag {
const is_static = d.storage_class == .static;
if (ty.isFunc() and d.storage_class != .typedef) {
switch (d.storage_class) {
.none, .@"extern" => {},
.static => |tok_i| if (p.func.ty != null) try p.errTok(.static_func_not_global, tok_i),
.typedef => unreachable,
.auto, .register => |tok_i| try p.errTok(.illegal_storage_on_func, tok_i),
}
if (d.thread_local) |tok_i| try p.errTok(.threadlocal_non_var, tok_i);
if (d.constexpr) |tok_i| try p.errTok(.illegal_storage_on_func, tok_i);
const is_inline = d.@"inline" != null;
if (is_static) {
if (is_inline) return .inline_static_fn_proto;
return .static_fn_proto;
} else {
if (is_inline) return .inline_fn_proto;
return .fn_proto;
}
} else {
if (d.@"inline") |tok_i| try p.errStr(.func_spec_non_func, tok_i, "inline");
// TODO move to attribute validation
if (d.noreturn) |tok_i| try p.errStr(.func_spec_non_func, tok_i, "_Noreturn");
switch (d.storage_class) {
.auto => if (p.func.ty == null and !p.comp.langopts.standard.atLeast(.c23)) {
try p.err(.illegal_storage_on_global);
},
.register => if (p.func.ty == null) try p.err(.illegal_storage_on_global),
.typedef => return .typedef,
else => {},
}
ty.qual.register = d.storage_class == .register;
const is_extern = d.storage_class == .@"extern" and !has_init;
if (d.thread_local != null) {
if (is_static) return .threadlocal_static_var;
if (is_extern) return .threadlocal_extern_var;
return .threadlocal_var;
} else {
if (is_static) return .static_var;
if (is_extern) return .extern_var;
return .@"var";
}
}
}
};
/// typeof
/// : keyword_typeof '(' typeName ')'
/// | keyword_typeof '(' expr ')'
fn typeof(p: *Parser) Error!?Type {
var unqual = false;
switch (p.tok_ids[p.tok_i]) {
.keyword_typeof, .keyword_typeof1, .keyword_typeof2 => p.tok_i += 1,
.keyword_typeof_unqual => {
p.tok_i += 1;
unqual = true;
},
else => return null,
}
const l_paren = try p.expectToken(.l_paren);
if (try p.typeName()) |ty| {
try p.expectClosing(l_paren, .r_paren);
if (ty.is(.invalid)) return null;
const typeof_ty = try p.arena.create(Type);
typeof_ty.* = .{
.data = ty.data,
.qual = if (unqual) .{} else ty.qual.inheritFromTypeof(),
.specifier = ty.specifier,
};
return Type{
.data = .{ .sub_type = typeof_ty },
.specifier = .typeof_type,
};
}
const typeof_expr = try p.parseNoEval(expr);
try typeof_expr.expect(p);
try p.expectClosing(l_paren, .r_paren);
// Special case nullptr_t since it's defined as typeof(nullptr)
if (typeof_expr.ty.is(.nullptr_t)) {
return Type{
.specifier = .nullptr_t,
.qual = if (unqual) .{} else typeof_expr.ty.qual.inheritFromTypeof(),
};
} else if (typeof_expr.ty.is(.invalid)) {
return null;
}
const inner = try p.arena.create(Type.Expr);
inner.* = .{
.node = typeof_expr.node,
.ty = .{
.data = typeof_expr.ty.data,
.qual = if (unqual) .{} else typeof_expr.ty.qual.inheritFromTypeof(),
.specifier = typeof_expr.ty.specifier,
.decayed = typeof_expr.ty.decayed,
},
};
return Type{
.data = .{ .expr = inner },
.specifier = .typeof_expr,
.decayed = typeof_expr.ty.decayed,
};
}
/// declSpec: (storageClassSpec | typeSpec | typeQual | funcSpec | alignSpec)+
/// funcSpec : keyword_inline | keyword_noreturn
fn declSpec(p: *Parser) Error!?DeclSpec {
var d: DeclSpec = .{ .ty = .{ .specifier = undefined } };
var spec: Type.Builder = .{};
var combined_auto = !p.comp.langopts.standard.atLeast(.c23);
const start = p.tok_i;
while (true) {
if (!combined_auto and d.storage_class == .auto) {
try spec.combine(p, .c23_auto, d.storage_class.auto);
combined_auto = true;
}
if (try p.storageClassSpec(&d)) continue;
if (try p.typeSpec(&spec)) continue;
const id = p.tok_ids[p.tok_i];
switch (id) {
.keyword_inline, .keyword_inline1, .keyword_inline2 => {
if (d.@"inline" != null) {
try p.errStr(.duplicate_decl_spec, p.tok_i, "inline");
}
d.@"inline" = p.tok_i;
},
.keyword_noreturn => {
if (d.noreturn != null) {
try p.errStr(.duplicate_decl_spec, p.tok_i, "_Noreturn");
}
d.noreturn = p.tok_i;
},
else => break,
}
p.tok_i += 1;
}
if (p.tok_i == start) return null;
d.ty = try spec.finish(p);
d.auto_type = spec.auto_type_tok;
return d;
}
/// storageClassSpec:
/// : keyword_typedef
/// | keyword_extern
/// | keyword_static
/// | keyword_threadlocal
/// | keyword_auto
/// | keyword_register
fn storageClassSpec(p: *Parser, d: *DeclSpec) Error!bool {
const start = p.tok_i;
while (true) {
const id = p.tok_ids[p.tok_i];
switch (id) {
.keyword_typedef,
.keyword_extern,
.keyword_static,
.keyword_auto,
.keyword_register,
=> {
if (d.storage_class != .none) {
try p.errStr(.multiple_storage_class, p.tok_i, @tagName(d.storage_class));
return error.ParsingFailed;
}
if (d.thread_local != null) {
switch (id) {
.keyword_extern, .keyword_static => {},
else => try p.errStr(.cannot_combine_spec, p.tok_i, id.lexeme().?),
}
if (d.constexpr) |tok| try p.errStr(.cannot_combine_spec, p.tok_i, p.tok_ids[tok].lexeme().?);
}
if (d.constexpr != null) {
switch (id) {
.keyword_auto, .keyword_register, .keyword_static => {},
else => try p.errStr(.cannot_combine_spec, p.tok_i, id.lexeme().?),
}
if (d.thread_local) |tok| try p.errStr(.cannot_combine_spec, p.tok_i, p.tok_ids[tok].lexeme().?);
}
switch (id) {
.keyword_typedef => d.storage_class = .{ .typedef = p.tok_i },
.keyword_extern => d.storage_class = .{ .@"extern" = p.tok_i },
.keyword_static => d.storage_class = .{ .static = p.tok_i },
.keyword_auto => d.storage_class = .{ .auto = p.tok_i },
.keyword_register => d.storage_class = .{ .register = p.tok_i },
else => unreachable,
}
},
.keyword_thread_local,
.keyword_c23_thread_local,
=> {
if (d.thread_local != null) {
try p.errStr(.duplicate_decl_spec, p.tok_i, id.lexeme().?);
}
if (d.constexpr) |tok| try p.errStr(.cannot_combine_spec, p.tok_i, p.tok_ids[tok].lexeme().?);
switch (d.storage_class) {
.@"extern", .none, .static => {},
else => try p.errStr(.cannot_combine_spec, p.tok_i, @tagName(d.storage_class)),
}
d.thread_local = p.tok_i;
},
.keyword_constexpr => {
if (d.constexpr != null) {
try p.errStr(.duplicate_decl_spec, p.tok_i, id.lexeme().?);
}
if (d.thread_local) |tok| try p.errStr(.cannot_combine_spec, p.tok_i, p.tok_ids[tok].lexeme().?);
switch (d.storage_class) {
.auto, .register, .none, .static => {},
else => try p.errStr(.cannot_combine_spec, p.tok_i, @tagName(d.storage_class)),
}
d.constexpr = p.tok_i;
},
else => break,
}
p.tok_i += 1;
}
return p.tok_i != start;
}
const InitDeclarator = struct { d: Declarator, initializer: Result = .{} };
/// attribute
/// : attrIdentifier
/// | attrIdentifier '(' identifier ')'
/// | attrIdentifier '(' identifier (',' expr)+ ')'
/// | attrIdentifier '(' (expr (',' expr)*)? ')'
fn attribute(p: *Parser, kind: Attribute.Kind, namespace: ?[]const u8) Error!?TentativeAttribute {
const name_tok = p.tok_i;
switch (p.tok_ids[p.tok_i]) {
.keyword_const, .keyword_const1, .keyword_const2 => p.tok_i += 1,
else => _ = try p.expectIdentifier(),
}
const name = p.tokSlice(name_tok);
const attr = Attribute.fromString(kind, namespace, name) orelse {
const tag: Diagnostics.Tag = if (kind == .declspec) .declspec_attr_not_supported else .unknown_attribute;
try p.errStr(tag, name_tok, name);
if (p.eatToken(.l_paren)) |_| p.skipTo(.r_paren);
return null;
};
const required_count = Attribute.requiredArgCount(attr);
var arguments = Attribute.initArguments(attr, name_tok);
var arg_idx: u32 = 0;
switch (p.tok_ids[p.tok_i]) {
.comma, .r_paren => {}, // will be consumed in attributeList
.l_paren => blk: {
p.tok_i += 1;
if (p.eatToken(.r_paren)) |_| break :blk;
if (Attribute.wantsIdentEnum(attr)) {
if (try p.eatIdentifier()) |ident| {
if (Attribute.diagnoseIdent(attr, &arguments, p.tokSlice(ident))) |msg| {
try p.errExtra(msg.tag, ident, msg.extra);
p.skipTo(.r_paren);
return error.ParsingFailed;
}
} else {
try p.errExtra(.attribute_requires_identifier, name_tok, .{ .str = name });
return error.ParsingFailed;
}
} else {
const arg_start = p.tok_i;
var first_expr = try p.assignExpr();
try first_expr.expect(p);
if (try p.diagnose(attr, &arguments, arg_idx, first_expr)) |msg| {
try p.errExtra(msg.tag, arg_start, msg.extra);
p.skipTo(.r_paren);
return error.ParsingFailed;
}
}
arg_idx += 1;
while (p.eatToken(.r_paren) == null) : (arg_idx += 1) {
_ = try p.expectToken(.comma);
const arg_start = p.tok_i;
var arg_expr = try p.assignExpr();
try arg_expr.expect(p);
if (try p.diagnose(attr, &arguments, arg_idx, arg_expr)) |msg| {
try p.errExtra(msg.tag, arg_start, msg.extra);
p.skipTo(.r_paren);
return error.ParsingFailed;
}
}
},
else => {},
}
if (arg_idx < required_count) {
try p.errExtra(.attribute_not_enough_args, name_tok, .{ .attr_arg_count = .{ .attribute = attr, .expected = required_count } });
return error.ParsingFailed;
}
return TentativeAttribute{ .attr = .{ .tag = attr, .args = arguments, .syntax = kind.toSyntax() }, .tok = name_tok };
}
fn diagnose(p: *Parser, attr: Attribute.Tag, arguments: *Attribute.Arguments, arg_idx: u32, res: Result) !?Diagnostics.Message {
if (Attribute.wantsAlignment(attr, arg_idx)) {
return Attribute.diagnoseAlignment(attr, arguments, arg_idx, res, p);
}
const node = p.nodes.get(@intFromEnum(res.node));
return Attribute.diagnose(attr, arguments, arg_idx, res, node, p);
}
/// attributeList : (attribute (',' attribute)*)?
fn gnuAttributeList(p: *Parser) Error!void {
if (p.tok_ids[p.tok_i] == .r_paren) return;
if (try p.attribute(.gnu, null)) |attr| try p.attr_buf.append(p.gpa, attr);
while (p.tok_ids[p.tok_i] != .r_paren) {
_ = try p.expectToken(.comma);
if (try p.attribute(.gnu, null)) |attr| try p.attr_buf.append(p.gpa, attr);
}
}
fn c23AttributeList(p: *Parser) Error!void {
while (p.tok_ids[p.tok_i] != .r_bracket) {
const namespace_tok = try p.expectIdentifier();
var namespace: ?[]const u8 = null;
if (p.eatToken(.colon_colon)) |_| {
namespace = p.tokSlice(namespace_tok);
} else {
p.tok_i -= 1;
}
if (try p.attribute(.c23, namespace)) |attr| try p.attr_buf.append(p.gpa, attr);
_ = p.eatToken(.comma);
}
}
fn msvcAttributeList(p: *Parser) Error!void {
while (p.tok_ids[p.tok_i] != .r_paren) {
if (try p.attribute(.declspec, null)) |attr| try p.attr_buf.append(p.gpa, attr);
_ = p.eatToken(.comma);
}
}
fn c23Attribute(p: *Parser) !bool {
if (!p.comp.langopts.standard.atLeast(.c23)) return false;
const bracket1 = p.eatToken(.l_bracket) orelse return false;
const bracket2 = p.eatToken(.l_bracket) orelse {
p.tok_i -= 1;
return false;
};
try p.c23AttributeList();
_ = try p.expectClosing(bracket2, .r_bracket);
_ = try p.expectClosing(bracket1, .r_bracket);
return true;
}
fn msvcAttribute(p: *Parser) !bool {
_ = p.eatToken(.keyword_declspec) orelse return false;
const l_paren = try p.expectToken(.l_paren);
try p.msvcAttributeList();
_ = try p.expectClosing(l_paren, .r_paren);
return true;
}
fn gnuAttribute(p: *Parser) !bool {
switch (p.tok_ids[p.tok_i]) {
.keyword_attribute1, .keyword_attribute2 => p.tok_i += 1,
else => return false,
}
const paren1 = try p.expectToken(.l_paren);
const paren2 = try p.expectToken(.l_paren);
try p.gnuAttributeList();
_ = try p.expectClosing(paren2, .r_paren);
_ = try p.expectClosing(paren1, .r_paren);
return true;
}
fn attributeSpecifier(p: *Parser) Error!void {
return attributeSpecifierExtra(p, null);
}
/// attributeSpecifier : (keyword_attribute '( '(' attributeList ')' ')')*
fn attributeSpecifierExtra(p: *Parser, declarator_name: ?TokenIndex) Error!void {
while (true) {
if (try p.gnuAttribute()) continue;
if (try p.c23Attribute()) continue;
const maybe_declspec_tok = p.tok_i;
const attr_buf_top = p.attr_buf.len;
if (try p.msvcAttribute()) {
if (declarator_name) |name_tok| {
try p.errTok(.declspec_not_allowed_after_declarator, maybe_declspec_tok);
try p.errTok(.declarator_name_tok, name_tok);
p.attr_buf.len = attr_buf_top;
}
continue;
}
break;
}
}
/// initDeclarator : declarator assembly? attributeSpecifier? ('=' initializer)?
fn initDeclarator(p: *Parser, decl_spec: *DeclSpec, attr_buf_top: usize) Error!?InitDeclarator {
const this_attr_buf_top = p.attr_buf.len;
defer p.attr_buf.len = this_attr_buf_top;
var init_d = InitDeclarator{
.d = (try p.declarator(decl_spec.ty, .normal)) orelse return null,
};
if (decl_spec.ty.is(.c23_auto) and !init_d.d.ty.is(.c23_auto)) {
try p.errTok(.c23_auto_plain_declarator, decl_spec.storage_class.auto);
return error.ParsingFailed;
}
try p.attributeSpecifierExtra(init_d.d.name);
_ = try p.assembly(.decl_label);
try p.attributeSpecifierExtra(init_d.d.name);
var apply_var_attributes = false;
if (decl_spec.storage_class == .typedef) {
if (decl_spec.auto_type) |tok_i| {
try p.errStr(.auto_type_not_allowed, tok_i, "typedef");
return error.ParsingFailed;
}
init_d.d.ty = try Attribute.applyTypeAttributes(p, init_d.d.ty, attr_buf_top, null);
} else if (init_d.d.ty.isFunc()) {
init_d.d.ty = try Attribute.applyFunctionAttributes(p, init_d.d.ty, attr_buf_top);
} else {
apply_var_attributes = true;
}
const c23_auto = init_d.d.ty.is(.c23_auto);
const auto_type = init_d.d.ty.is(.auto_type);
if (p.eatToken(.equal)) |eq| init: {
if (decl_spec.storage_class == .typedef or
(init_d.d.func_declarator != null and init_d.d.ty.isFunc()))
{
try p.errTok(.illegal_initializer, eq);
} else if (init_d.d.ty.is(.variable_len_array)) {
try p.errTok(.vla_init, eq);
} else if (decl_spec.storage_class == .@"extern") {
try p.err(.extern_initializer);
decl_spec.storage_class = .none;
}
if (init_d.d.ty.hasIncompleteSize() and !init_d.d.ty.is(.incomplete_array)) {
try p.errStr(.variable_incomplete_ty, init_d.d.name, try p.typeStr(init_d.d.ty));
return error.ParsingFailed;
}
if (p.tok_ids[p.tok_i] == .l_brace and init_d.d.ty.is(.c23_auto)) {
try p.errTok(.c23_auto_scalar_init, decl_spec.storage_class.auto);
return error.ParsingFailed;
}
try p.syms.pushScope(p);
defer p.syms.popScope();
const interned_name = try StrInt.intern(p.comp, p.tokSlice(init_d.d.name));
try p.syms.declareSymbol(p, interned_name, init_d.d.ty, init_d.d.name, .none);
if (c23_auto or auto_type) {
p.auto_type_decl_name = interned_name;
}
defer p.auto_type_decl_name = .empty;
var init_list_expr = try p.initializer(init_d.d.ty);
init_d.initializer = init_list_expr;
if (!init_list_expr.ty.isArray()) break :init;
if (init_d.d.ty.is(.incomplete_array)) {
init_d.d.ty.setIncompleteArrayLen(init_list_expr.ty.arrayLen() orelse break :init);
}
}
const name = init_d.d.name;
if (auto_type or c23_auto) {
if (init_d.initializer.node == .none) {
init_d.d.ty = Type.invalid;
if (c23_auto) {
try p.errStr(.c32_auto_requires_initializer, decl_spec.storage_class.auto, p.tokSlice(name));
} else {
try p.errStr(.auto_type_requires_initializer, name, p.tokSlice(name));
}
return init_d;
} else {
init_d.d.ty.specifier = init_d.initializer.ty.specifier;
init_d.d.ty.data = init_d.initializer.ty.data;
init_d.d.ty.decayed = init_d.initializer.ty.decayed;
}
}
if (apply_var_attributes) {
init_d.d.ty = try Attribute.applyVariableAttributes(p, init_d.d.ty, attr_buf_top, null);
}
if (decl_spec.storage_class != .typedef and init_d.d.ty.hasIncompleteSize()) incomplete: {
const specifier = init_d.d.ty.canonicalize(.standard).specifier;
if (decl_spec.storage_class == .@"extern") switch (specifier) {
.@"struct", .@"union", .@"enum" => break :incomplete,
.incomplete_array => {
init_d.d.ty.decayArray();
break :incomplete;
},
else => {},
};
// if there was an initializer expression it must have contained an error
if (init_d.initializer.node != .none) break :incomplete;
if (p.func.ty == null) {
if (specifier == .incomplete_array) {
// TODO properly check this after finishing parsing
try p.errStr(.tentative_array, name, try p.typeStr(init_d.d.ty));
break :incomplete;
} else if (init_d.d.ty.getRecord()) |record| {
_ = try p.tentative_defs.getOrPutValue(p.gpa, record.name, init_d.d.name);
break :incomplete;
} else if (init_d.d.ty.get(.@"enum")) |en| {
_ = try p.tentative_defs.getOrPutValue(p.gpa, en.data.@"enum".name, init_d.d.name);
break :incomplete;
}
}
try p.errStr(.variable_incomplete_ty, name, try p.typeStr(init_d.d.ty));
}
return init_d;
}
/// typeSpec
/// : keyword_void
/// | keyword_auto_type
/// | keyword_char
/// | keyword_short
/// | keyword_int
/// | keyword_long
/// | keyword_float
/// | keyword_double
/// | keyword_signed
/// | keyword_signed1
/// | keyword_signed2
/// | keyword_unsigned
/// | keyword_bool
/// | keyword_c23_bool
/// | keyword_complex
/// | atomicTypeSpec
/// | recordSpec
/// | enumSpec
/// | typedef // IDENTIFIER
/// | typeof
/// | keyword_bit_int '(' integerConstExpr ')'
/// atomicTypeSpec : keyword_atomic '(' typeName ')'
/// alignSpec
/// : keyword_alignas '(' typeName ')'
/// | keyword_alignas '(' integerConstExpr ')'
/// | keyword_c23_alignas '(' typeName ')'
/// | keyword_c23_alignas '(' integerConstExpr ')'
fn typeSpec(p: *Parser, ty: *Type.Builder) Error!bool {
const start = p.tok_i;
while (true) {
try p.attributeSpecifier();
if (try p.typeof()) |inner_ty| {
try ty.combineFromTypeof(p, inner_ty, start);
continue;
}
if (try p.typeQual(&ty.qual)) continue;
switch (p.tok_ids[p.tok_i]) {
.keyword_void => try ty.combine(p, .void, p.tok_i),
.keyword_auto_type => {
try p.errTok(.auto_type_extension, p.tok_i);
try ty.combine(p, .auto_type, p.tok_i);
},
.keyword_bool, .keyword_c23_bool => try ty.combine(p, .bool, p.tok_i),
.keyword_int8, .keyword_int8_2, .keyword_char => try ty.combine(p, .char, p.tok_i),
.keyword_int16, .keyword_int16_2, .keyword_short => try ty.combine(p, .short, p.tok_i),
.keyword_int32, .keyword_int32_2, .keyword_int => try ty.combine(p, .int, p.tok_i),
.keyword_long => try ty.combine(p, .long, p.tok_i),
.keyword_int64, .keyword_int64_2 => try ty.combine(p, .long_long, p.tok_i),
.keyword_int128 => try ty.combine(p, .int128, p.tok_i),
.keyword_signed, .keyword_signed1, .keyword_signed2 => try ty.combine(p, .signed, p.tok_i),
.keyword_unsigned => try ty.combine(p, .unsigned, p.tok_i),
.keyword_fp16 => try ty.combine(p, .fp16, p.tok_i),
.keyword_float16 => try ty.combine(p, .float16, p.tok_i),
.keyword_float => try ty.combine(p, .float, p.tok_i),
.keyword_double => try ty.combine(p, .double, p.tok_i),
.keyword_complex => try ty.combine(p, .complex, p.tok_i),
.keyword_float128_1, .keyword_float128_2 => {
if (!p.comp.hasFloat128()) {
try p.errStr(.type_not_supported_on_target, p.tok_i, p.tok_ids[p.tok_i].lexeme().?);
}
try ty.combine(p, .float128, p.tok_i);
},
.keyword_atomic => {
const atomic_tok = p.tok_i;
p.tok_i += 1;
const l_paren = p.eatToken(.l_paren) orelse {
// _Atomic qualifier not _Atomic(typeName)
p.tok_i = atomic_tok;
break;
};
const inner_ty = (try p.typeName()) orelse {
try p.err(.expected_type);
return error.ParsingFailed;
};
try p.expectClosing(l_paren, .r_paren);
const new_spec = Type.Builder.fromType(inner_ty);
try ty.combine(p, new_spec, atomic_tok);
if (ty.qual.atomic != null)
try p.errStr(.duplicate_decl_spec, atomic_tok, "atomic")
else
ty.qual.atomic = atomic_tok;
continue;
},
.keyword_alignas,
.keyword_c23_alignas,
=> {
const align_tok = p.tok_i;
p.tok_i += 1;
const l_paren = try p.expectToken(.l_paren);
const typename_start = p.tok_i;
if (try p.typeName()) |inner_ty| {
if (!inner_ty.alignable()) {
try p.errStr(.invalid_alignof, typename_start, try p.typeStr(inner_ty));
}
const alignment = Attribute.Alignment{ .requested = inner_ty.alignof(p.comp) };
try p.attr_buf.append(p.gpa, .{
.attr = .{ .tag = .aligned, .args = .{
.aligned = .{ .alignment = alignment, .__name_tok = align_tok },
}, .syntax = .keyword },
.tok = align_tok,
});
} else {
const arg_start = p.tok_i;
const res = try p.integerConstExpr(.no_const_decl_folding);
if (!res.val.isZero(p.comp)) {
var args = Attribute.initArguments(.aligned, align_tok);
if (try p.diagnose(.aligned, &args, 0, res)) |msg| {
try p.errExtra(msg.tag, arg_start, msg.extra);
p.skipTo(.r_paren);
return error.ParsingFailed;
}
args.aligned.alignment.?.node = res.node;
try p.attr_buf.append(p.gpa, .{
.attr = .{ .tag = .aligned, .args = args, .syntax = .keyword },
.tok = align_tok,
});
}
}
try p.expectClosing(l_paren, .r_paren);
continue;
},
.keyword_stdcall,
.keyword_stdcall2,
.keyword_thiscall,
.keyword_thiscall2,
.keyword_vectorcall,
.keyword_vectorcall2,
=> try p.attr_buf.append(p.gpa, .{
.attr = .{ .tag = .calling_convention, .args = .{
.calling_convention = .{ .cc = switch (p.tok_ids[p.tok_i]) {
.keyword_stdcall,
.keyword_stdcall2,
=> .stdcall,
.keyword_thiscall,
.keyword_thiscall2,
=> .thiscall,
.keyword_vectorcall,
.keyword_vectorcall2,
=> .vectorcall,
else => unreachable,
} },
}, .syntax = .keyword },
.tok = p.tok_i,
}),
.keyword_struct, .keyword_union => {
const tag_tok = p.tok_i;
const record_ty = try p.recordSpec();
try ty.combine(p, Type.Builder.fromType(record_ty), tag_tok);
continue;
},
.keyword_enum => {
const tag_tok = p.tok_i;
const enum_ty = try p.enumSpec();
try ty.combine(p, Type.Builder.fromType(enum_ty), tag_tok);
continue;
},
.identifier, .extended_identifier => {
var interned_name = try StrInt.intern(p.comp, p.tokSlice(p.tok_i));
var declspec_found = false;
if (interned_name == p.string_ids.declspec_id) {
try p.errTok(.declspec_not_enabled, p.tok_i);
p.tok_i += 1;
if (p.eatToken(.l_paren)) |_| {
p.skipTo(.r_paren);
continue;
}
declspec_found = true;
}
if (ty.typedef != null) break;
if (declspec_found) {
interned_name = try StrInt.intern(p.comp, p.tokSlice(p.tok_i));
}
const typedef = (try p.syms.findTypedef(p, interned_name, p.tok_i, ty.specifier != .none)) orelse break;
if (!ty.combineTypedef(p, typedef.ty, typedef.tok)) break;
},
.keyword_bit_int => {
try p.err(.bit_int);
const bit_int_tok = p.tok_i;
p.tok_i += 1;
const l_paren = try p.expectToken(.l_paren);
const res = try p.integerConstExpr(.gnu_folding_extension);
try p.expectClosing(l_paren, .r_paren);
var bits: u64 = undefined;
if (res.val.opt_ref == .none) {
try p.errTok(.expected_integer_constant_expr, bit_int_tok);
return error.ParsingFailed;
} else if (res.val.compare(.lte, Value.zero, p.comp)) {
bits = 0;
} else {
bits = res.val.toInt(u64, p.comp) orelse std.math.maxInt(u64);
}
try ty.combine(p, .{ .bit_int = bits }, bit_int_tok);
continue;
},
else => break,
}
// consume single token specifiers here
p.tok_i += 1;
}
return p.tok_i != start;
}
fn getAnonymousName(p: *Parser, kind_tok: TokenIndex) !StringId {
const loc = p.pp.tokens.items(.loc)[kind_tok];
const source = p.comp.getSource(loc.id);
const line_col = source.lineCol(loc);
const kind_str = switch (p.tok_ids[kind_tok]) {
.keyword_struct, .keyword_union, .keyword_enum => p.tokSlice(kind_tok),
else => "record field",
};
const str = try std.fmt.allocPrint(
p.arena,
"(anonymous {s} at {s}:{d}:{d})",
.{ kind_str, source.path, line_col.line_no, line_col.col },
);
return StrInt.intern(p.comp, str);
}
/// recordSpec
/// : (keyword_struct | keyword_union) IDENTIFIER? { recordDecl* }
/// | (keyword_struct | keyword_union) IDENTIFIER
fn recordSpec(p: *Parser) Error!Type {
const starting_pragma_pack = p.pragma_pack;
const kind_tok = p.tok_i;
const is_struct = p.tok_ids[kind_tok] == .keyword_struct;
p.tok_i += 1;
const attr_buf_top = p.attr_buf.len;
defer p.attr_buf.len = attr_buf_top;
try p.attributeSpecifier();
const maybe_ident = try p.eatIdentifier();
const l_brace = p.eatToken(.l_brace) orelse {
const ident = maybe_ident orelse {
try p.err(.ident_or_l_brace);
return error.ParsingFailed;
};
// check if this is a reference to a previous type
const interned_name = try StrInt.intern(p.comp, p.tokSlice(ident));
if (try p.syms.findTag(p, interned_name, p.tok_ids[kind_tok], ident, p.tok_ids[p.tok_i])) |prev| {
return prev.ty;
} else {
// this is a forward declaration, create a new record Type.
const record_ty = try Type.Record.create(p.arena, interned_name);
const ty = try Attribute.applyTypeAttributes(p, .{
.specifier = if (is_struct) .@"struct" else .@"union",
.data = .{ .record = record_ty },
}, attr_buf_top, null);
try p.syms.define(p.gpa, .{
.kind = if (is_struct) .@"struct" else .@"union",
.name = interned_name,
.tok = ident,
.ty = ty,
.val = .{},
});
try p.decl_buf.append(try p.addNode(.{
.tag = if (is_struct) .struct_forward_decl else .union_forward_decl,
.ty = ty,
.data = .{ .decl_ref = ident },
.loc = @enumFromInt(ident),
}));
return ty;
}
};
var done = false;
errdefer if (!done) p.skipTo(.r_brace);
// Get forward declared type or create a new one
var defined = false;
const record_ty: *Type.Record = if (maybe_ident) |ident| record_ty: {
const ident_str = p.tokSlice(ident);
const interned_name = try StrInt.intern(p.comp, ident_str);
if (try p.syms.defineTag(p, interned_name, p.tok_ids[kind_tok], ident)) |prev| {
if (!prev.ty.hasIncompleteSize()) {
// if the record isn't incomplete, this is a redefinition
try p.errStr(.redefinition, ident, ident_str);
try p.errTok(.previous_definition, prev.tok);
} else {
defined = true;
break :record_ty prev.ty.get(if (is_struct) .@"struct" else .@"union").?.data.record;
}
}
break :record_ty try Type.Record.create(p.arena, interned_name);
} else try Type.Record.create(p.arena, try p.getAnonymousName(kind_tok));
// Initially create ty as a regular non-attributed type, since attributes for a record
// can be specified after the closing rbrace, which we haven't encountered yet.
var ty = Type{
.specifier = if (is_struct) .@"struct" else .@"union",
.data = .{ .record = record_ty },
};
// declare a symbol for the type
// We need to replace the symbol's type if it has attributes
if (maybe_ident != null and !defined) {
try p.syms.define(p.gpa, .{
.kind = if (is_struct) .@"struct" else .@"union",
.name = record_ty.name,
.tok = maybe_ident.?,
.ty = ty,
.val = .{},
});
}
// reserve space for this record
try p.decl_buf.append(.none);
const decl_buf_top = p.decl_buf.items.len;
const record_buf_top = p.record_buf.items.len;
errdefer p.decl_buf.items.len = decl_buf_top - 1;
defer {
p.decl_buf.items.len = decl_buf_top;
p.record_buf.items.len = record_buf_top;
}
const old_record = p.record;
const old_members = p.record_members.items.len;
const old_field_attr_start = p.field_attr_buf.items.len;
p.record = .{
.kind = p.tok_ids[kind_tok],
.start = p.record_members.items.len,
.field_attr_start = p.field_attr_buf.items.len,
};
defer p.record = old_record;
defer p.record_members.items.len = old_members;
defer p.field_attr_buf.items.len = old_field_attr_start;
try p.recordDecls();
if (p.record.flexible_field) |some| {
if (p.record_buf.items[record_buf_top..].len == 1 and is_struct) {
try p.errTok(.flexible_in_empty, some);
}
}
for (p.record_buf.items[record_buf_top..]) |field| {
if (field.ty.hasIncompleteSize() and !field.ty.is(.incomplete_array)) break;
} else {
record_ty.fields = try p.arena.dupe(Type.Record.Field, p.record_buf.items[record_buf_top..]);
}
const attr_count = p.field_attr_buf.items.len - old_field_attr_start;
const record_decls = p.decl_buf.items[decl_buf_top..];
if (attr_count > 0) {
if (attr_count != record_decls.len) {
// A mismatch here means that non-field decls were parsed. This can happen if there were
// parse errors during attribute parsing. Bail here because if there are any field attributes,
// there must be exactly one per field.
return error.ParsingFailed;
}
const field_attr_slice = p.field_attr_buf.items[old_field_attr_start..];
const duped = try p.arena.dupe([]const Attribute, field_attr_slice);
record_ty.field_attributes = duped.ptr;
}
if (p.record_buf.items.len == record_buf_top) {
try p.errStr(.empty_record, kind_tok, p.tokSlice(kind_tok));
try p.errStr(.empty_record_size, kind_tok, p.tokSlice(kind_tok));
}
try p.expectClosing(l_brace, .r_brace);
done = true;
try p.attributeSpecifier();
ty = try Attribute.applyTypeAttributes(p, .{
.specifier = if (is_struct) .@"struct" else .@"union",
.data = .{ .record = record_ty },
}, attr_buf_top, null);
if (ty.specifier == .attributed and maybe_ident != null) {
const ident_str = p.tokSlice(maybe_ident.?);
const interned_name = try StrInt.intern(p.comp, ident_str);
const ptr = p.syms.getPtr(interned_name, .tags);
ptr.ty = ty;
}
if (!ty.hasIncompleteSize()) {
const pragma_pack_value = switch (p.comp.langopts.emulate) {
.clang => starting_pragma_pack,
.gcc => p.pragma_pack,
// TODO: msvc considers `#pragma pack` on a per-field basis
.msvc => p.pragma_pack,
};
record_layout.compute(record_ty, ty, p.comp, pragma_pack_value) catch |er| switch (er) {
error.Overflow => try p.errStr(.record_too_large, maybe_ident orelse kind_tok, try p.typeStr(ty)),
};
}
// finish by creating a node
var node: Tree.Node = .{
.tag = if (is_struct) .struct_decl_two else .union_decl_two,
.ty = ty,
.data = .{ .two = .{ .none, .none } },
.loc = @enumFromInt(maybe_ident orelse kind_tok),
};
switch (record_decls.len) {
0 => {},
1 => node.data = .{ .two = .{ record_decls[0], .none } },
2 => node.data = .{ .two = .{ record_decls[0], record_decls[1] } },
else => {
node.tag = if (is_struct) .struct_decl else .union_decl;
node.data = .{ .range = try p.addList(record_decls) };
},
}
p.decl_buf.items[decl_buf_top - 1] = try p.addNode(node);
if (p.func.ty == null) {
_ = p.tentative_defs.remove(record_ty.name);
}
return ty;
}
/// recordDecl
/// : specQual (recordDeclarator (',' recordDeclarator)*)? ;
/// | staticAssert
fn recordDecls(p: *Parser) Error!void {
while (true) {
if (try p.pragma()) continue;
if (try p.parseOrNextDecl(staticAssert)) continue;
if (p.eatToken(.keyword_extension)) |_| {
const saved_extension = p.extension_suppressed;
defer p.extension_suppressed = saved_extension;
p.extension_suppressed = true;
if (try p.parseOrNextDecl(recordDeclarator)) continue;
try p.err(.expected_type);
p.nextExternDecl();
continue;
}
if (try p.parseOrNextDecl(recordDeclarator)) continue;
break;
}
}
/// recordDeclarator : keyword_extension? declarator (':' integerConstExpr)?
fn recordDeclarator(p: *Parser) Error!bool {
const attr_buf_top = p.attr_buf.len;
defer p.attr_buf.len = attr_buf_top;
const base_ty = (try p.specQual()) orelse return false;
try p.attributeSpecifier(); // .record
while (true) {
const this_decl_top = p.attr_buf.len;
defer p.attr_buf.len = this_decl_top;
try p.attributeSpecifier();
// 0 means unnamed
var name_tok: TokenIndex = 0;
var ty = base_ty;
if (ty.is(.auto_type)) {
try p.errStr(.auto_type_not_allowed, p.tok_i, if (p.record.kind == .keyword_struct) "struct member" else "union member");
ty = Type.invalid;
}
var bits_node: NodeIndex = .none;
var bits: ?u32 = null;
const first_tok = p.tok_i;
if (try p.declarator(ty, .record)) |d| {
name_tok = d.name;
ty = d.ty;
}
if (p.eatToken(.colon)) |_| bits: {
const bits_tok = p.tok_i;
const res = try p.integerConstExpr(.gnu_folding_extension);
if (!ty.isInt()) {
try p.errStr(.non_int_bitfield, first_tok, try p.typeStr(ty));
break :bits;
}
if (res.val.opt_ref == .none) {
try p.errTok(.expected_integer_constant_expr, bits_tok);
break :bits;
} else if (res.val.compare(.lt, Value.zero, p.comp)) {
try p.errStr(.negative_bitwidth, first_tok, try res.str(p));
break :bits;
}
// incomplete size error is reported later
const bit_size = ty.bitSizeof(p.comp) orelse break :bits;
const bits_unchecked = res.val.toInt(u32, p.comp) orelse std.math.maxInt(u32);
if (bits_unchecked > bit_size) {
try p.errTok(.bitfield_too_big, name_tok);
break :bits;
} else if (bits_unchecked == 0 and name_tok != 0) {
try p.errTok(.zero_width_named_field, name_tok);
break :bits;
}
bits = bits_unchecked;
bits_node = res.node;
}
try p.attributeSpecifier(); // .record
const to_append = try Attribute.applyFieldAttributes(p, &ty, attr_buf_top);
const any_fields_have_attrs = p.field_attr_buf.items.len > p.record.field_attr_start;
if (any_fields_have_attrs) {
try p.field_attr_buf.append(to_append);
} else {
if (to_append.len > 0) {
const preceding = p.record_members.items.len - p.record.start;
if (preceding > 0) {
try p.field_attr_buf.appendNTimes(&.{}, preceding);
}
try p.field_attr_buf.append(to_append);
}
}
if (name_tok == 0 and bits_node == .none) unnamed: {
if (ty.is(.@"enum") or ty.hasIncompleteSize()) break :unnamed;
if (ty.isAnonymousRecord(p.comp)) {
// An anonymous record appears as indirect fields on the parent
try p.record_buf.append(.{
.name = try p.getAnonymousName(first_tok),
.ty = ty,
});
const node = try p.addNode(.{
.tag = .indirect_record_field_decl,
.ty = ty,
.data = undefined,
.loc = @enumFromInt(first_tok),
});
try p.decl_buf.append(node);
try p.record.addFieldsFromAnonymous(p, ty);
break; // must be followed by a semicolon
}
try p.err(.missing_declaration);
} else {
const interned_name = if (name_tok != 0) try StrInt.intern(p.comp, p.tokSlice(name_tok)) else try p.getAnonymousName(first_tok);
try p.record_buf.append(.{
.name = interned_name,
.ty = ty,
.name_tok = name_tok,
.bit_width = bits,
});
if (name_tok != 0) try p.record.addField(p, interned_name, name_tok);
const node = try p.addNode(.{
.tag = .record_field_decl,
.ty = ty,
.data = .{ .decl = .{ .name = name_tok, .node = bits_node } },
.loc = @enumFromInt(if (name_tok != 0) name_tok else first_tok),
});
try p.decl_buf.append(node);
}
if (ty.isFunc()) {
try p.errTok(.func_field, first_tok);
} else if (ty.is(.variable_len_array)) {
try p.errTok(.vla_field, first_tok);
} else if (ty.is(.incomplete_array)) {
if (p.record.kind == .keyword_union) {
try p.errTok(.flexible_in_union, first_tok);
}
if (p.record.flexible_field) |some| {
if (p.record.kind == .keyword_struct) {
try p.errTok(.flexible_non_final, some);
}
}
p.record.flexible_field = first_tok;
} else if (ty.specifier != .invalid and ty.hasIncompleteSize()) {
try p.errStr(.field_incomplete_ty, first_tok, try p.typeStr(ty));
} else if (p.record.flexible_field) |some| {
if (some != first_tok and p.record.kind == .keyword_struct) try p.errTok(.flexible_non_final, some);
}
if (p.eatToken(.comma) == null) break;
}
if (p.eatToken(.semicolon) == null) {
const tok_id = p.tok_ids[p.tok_i];
if (tok_id == .r_brace) {
try p.err(.missing_semicolon);
} else {
return p.errExpectedToken(.semicolon, tok_id);
}
}
return true;
}
/// specQual : (typeSpec | typeQual | alignSpec)+
fn specQual(p: *Parser) Error!?Type {
var spec: Type.Builder = .{};
if (try p.typeSpec(&spec)) {
return try spec.finish(p);
}
return null;
}
/// enumSpec
/// : keyword_enum IDENTIFIER? (: typeName)? { enumerator (',' enumerator)? ',') }
/// | keyword_enum IDENTIFIER (: typeName)?
fn enumSpec(p: *Parser) Error!Type {
const enum_tok = p.tok_i;
p.tok_i += 1;
const attr_buf_top = p.attr_buf.len;
defer p.attr_buf.len = attr_buf_top;
try p.attributeSpecifier();
const maybe_ident = try p.eatIdentifier();
const fixed_ty = if (p.eatToken(.colon)) |colon| fixed: {
const ty_start = p.tok_i;
const fixed = (try p.specQual()) orelse {
if (p.record.kind != .invalid) {
// This is a bit field.
p.tok_i -= 1;
break :fixed null;
}
try p.err(.expected_type);
try p.errTok(.enum_fixed, colon);
break :fixed null;
};
if (!fixed.isInt() or fixed.is(.@"enum")) {
try p.errStr(.invalid_type_underlying_enum, ty_start, try p.typeStr(fixed));
break :fixed Type.int;
}
try p.errTok(.enum_fixed, colon);
break :fixed fixed;
} else null;
const l_brace = p.eatToken(.l_brace) orelse {
const ident = maybe_ident orelse {
try p.err(.ident_or_l_brace);
return error.ParsingFailed;
};
// check if this is a reference to a previous type
const interned_name = try StrInt.intern(p.comp, p.tokSlice(ident));
if (try p.syms.findTag(p, interned_name, .keyword_enum, ident, p.tok_ids[p.tok_i])) |prev| {
// only check fixed underlying type in forward declarations and not in references.
if (p.tok_ids[p.tok_i] == .semicolon)
try p.checkEnumFixedTy(fixed_ty, ident, prev);
return prev.ty;
} else {
// this is a forward declaration, create a new enum Type.
const enum_ty = try Type.Enum.create(p.arena, interned_name, fixed_ty);
const ty = try Attribute.applyTypeAttributes(p, .{
.specifier = .@"enum",
.data = .{ .@"enum" = enum_ty },
}, attr_buf_top, null);
try p.syms.define(p.gpa, .{
.kind = .@"enum",
.name = interned_name,
.tok = ident,
.ty = ty,
.val = .{},
});
try p.decl_buf.append(try p.addNode(.{
.tag = .enum_forward_decl,
.ty = ty,
.data = .{ .decl_ref = ident },
.loc = @enumFromInt(ident),
}));
return ty;
}
};
var done = false;
errdefer if (!done) p.skipTo(.r_brace);
// Get forward declared type or create a new one
var defined = false;
const enum_ty: *Type.Enum = if (maybe_ident) |ident| enum_ty: {
const ident_str = p.tokSlice(ident);
const interned_name = try StrInt.intern(p.comp, ident_str);
if (try p.syms.defineTag(p, interned_name, .keyword_enum, ident)) |prev| {
const enum_ty = prev.ty.get(.@"enum").?.data.@"enum";
if (!enum_ty.isIncomplete() and !enum_ty.fixed) {
// if the enum isn't incomplete, this is a redefinition
try p.errStr(.redefinition, ident, ident_str);
try p.errTok(.previous_definition, prev.tok);
} else {
try p.checkEnumFixedTy(fixed_ty, ident, prev);
defined = true;
break :enum_ty enum_ty;
}
}
break :enum_ty try Type.Enum.create(p.arena, interned_name, fixed_ty);
} else try Type.Enum.create(p.arena, try p.getAnonymousName(enum_tok), fixed_ty);
// reserve space for this enum
try p.decl_buf.append(.none);
const decl_buf_top = p.decl_buf.items.len;
const list_buf_top = p.list_buf.items.len;
const enum_buf_top = p.enum_buf.items.len;
errdefer p.decl_buf.items.len = decl_buf_top - 1;
defer {
p.decl_buf.items.len = decl_buf_top;
p.list_buf.items.len = list_buf_top;
p.enum_buf.items.len = enum_buf_top;
}
var e = Enumerator.init(fixed_ty);
while (try p.enumerator(&e)) |field_and_node| {
try p.enum_buf.append(field_and_node.field);
try p.list_buf.append(field_and_node.node);
if (p.eatToken(.comma) == null) break;
}
if (p.enum_buf.items.len == enum_buf_top) try p.err(.empty_enum);
try p.expectClosing(l_brace, .r_brace);
done = true;
try p.attributeSpecifier();
const ty = try Attribute.applyTypeAttributes(p, .{
.specifier = .@"enum",
.data = .{ .@"enum" = enum_ty },
}, attr_buf_top, null);
if (!enum_ty.fixed) {
const tag_specifier = try e.getTypeSpecifier(p, ty.enumIsPacked(p.comp), maybe_ident orelse enum_tok);
enum_ty.tag_ty = .{ .specifier = tag_specifier };
}
const enum_fields = p.enum_buf.items[enum_buf_top..];
const field_nodes = p.list_buf.items[list_buf_top..];
if (fixed_ty == null) {
for (enum_fields, 0..) |*field, i| {
if (field.ty.eql(Type.int, p.comp, false)) continue;
const sym = p.syms.get(field.name, .vars) orelse continue;
if (sym.kind != .enumeration) continue; // already an error
var res = Result{ .node = field.node, .ty = field.ty, .val = sym.val };
const dest_ty = if (p.comp.fixedEnumTagSpecifier()) |some|
Type{ .specifier = some }
else if (try res.intFitsInType(p, Type.int))
Type.int
else if (!res.ty.eql(enum_ty.tag_ty, p.comp, false))
enum_ty.tag_ty
else
continue;
const symbol = p.syms.getPtr(field.name, .vars);
_ = try symbol.val.intCast(dest_ty, p.comp);
symbol.ty = dest_ty;
p.nodes.items(.ty)[@intFromEnum(field_nodes[i])] = dest_ty;
field.ty = dest_ty;
res.ty = dest_ty;
if (res.node != .none) {
try res.implicitCast(p, .int_cast);
field.node = res.node;
p.nodes.items(.data)[@intFromEnum(field_nodes[i])].decl.node = res.node;
}
}
}
enum_ty.fields = try p.arena.dupe(Type.Enum.Field, enum_fields);
// declare a symbol for the type
if (maybe_ident != null and !defined) {
try p.syms.define(p.gpa, .{
.kind = .@"enum",
.name = enum_ty.name,
.ty = ty,
.tok = maybe_ident.?,
.val = .{},
});
}
// finish by creating a node
var node: Tree.Node = .{
.tag = .enum_decl_two,
.ty = ty,
.data = .{
.two = .{ .none, .none },
},
.loc = @enumFromInt(maybe_ident orelse enum_tok),
};
switch (field_nodes.len) {
0 => {},
1 => node.data = .{ .two = .{ field_nodes[0], .none } },
2 => node.data = .{ .two = .{ field_nodes[0], field_nodes[1] } },
else => {
node.tag = .enum_decl;
node.data = .{ .range = try p.addList(field_nodes) };
},
}
p.decl_buf.items[decl_buf_top - 1] = try p.addNode(node);
if (p.func.ty == null) {
_ = p.tentative_defs.remove(enum_ty.name);
}
return ty;
}
fn checkEnumFixedTy(p: *Parser, fixed_ty: ?Type, ident_tok: TokenIndex, prev: Symbol) !void {
const enum_ty = prev.ty.get(.@"enum").?.data.@"enum";
if (fixed_ty) |some| {
if (!enum_ty.fixed) {
try p.errTok(.enum_prev_nonfixed, ident_tok);
try p.errTok(.previous_definition, prev.tok);
return error.ParsingFailed;
}
if (!enum_ty.tag_ty.eql(some, p.comp, false)) {
const str = try p.typePairStrExtra(some, " (was ", enum_ty.tag_ty);
try p.errStr(.enum_different_explicit_ty, ident_tok, str);
try p.errTok(.previous_definition, prev.tok);
return error.ParsingFailed;
}
} else if (enum_ty.fixed) {
try p.errTok(.enum_prev_fixed, ident_tok);
try p.errTok(.previous_definition, prev.tok);
return error.ParsingFailed;
}
}
const Enumerator = struct {
res: Result,
num_positive_bits: usize = 0,
num_negative_bits: usize = 0,
fixed: bool,
fn init(fixed_ty: ?Type) Enumerator {
return .{
.res = .{ .ty = fixed_ty orelse .{ .specifier = .int } },
.fixed = fixed_ty != null,
};
}
/// Increment enumerator value adjusting type if needed.
fn incr(e: *Enumerator, p: *Parser, tok: TokenIndex) !void {
e.res.node = .none;
const old_val = e.res.val;
if (old_val.opt_ref == .none) {
// First enumerator, set to 0 fits in all types.
e.res.val = Value.zero;
return;
}
if (try e.res.val.add(e.res.val, Value.one, e.res.ty, p.comp)) {
if (e.fixed) {
try p.errStr(.enum_not_representable_fixed, tok, try p.typeStr(e.res.ty));
return;
}
const new_ty = if (p.comp.nextLargestIntSameSign(e.res.ty)) |larger| blk: {
try p.errTok(.enumerator_overflow, tok);
break :blk larger;
} else blk: {
const signed = !e.res.ty.isUnsignedInt(p.comp);
const bit_size: u8 = @intCast(e.res.ty.bitSizeof(p.comp).? - @intFromBool(signed));
try p.errExtra(.enum_not_representable, tok, .{ .pow_2_as_string = bit_size });
break :blk Type{ .specifier = .ulong_long };
};
e.res.ty = new_ty;
_ = try e.res.val.add(old_val, Value.one, e.res.ty, p.comp);
}
}
/// Set enumerator value to specified value.
fn set(e: *Enumerator, p: *Parser, res: Result, tok: TokenIndex) !void {
if (res.ty.specifier == .invalid) return;
if (e.fixed and !res.ty.eql(e.res.ty, p.comp, false)) {
if (!try res.intFitsInType(p, e.res.ty)) {
try p.errStr(.enum_not_representable_fixed, tok, try p.typeStr(e.res.ty));
return error.ParsingFailed;
}
var copy = res;
copy.ty = e.res.ty;
try copy.implicitCast(p, .int_cast);
e.res = copy;
} else {
e.res = res;
try e.res.intCast(p, e.res.ty.integerPromotion(p.comp), tok);
}
}
fn getTypeSpecifier(e: *const Enumerator, p: *Parser, is_packed: bool, tok: TokenIndex) !Type.Specifier {
if (p.comp.fixedEnumTagSpecifier()) |tag_specifier| return tag_specifier;
const char_width = (Type{ .specifier = .schar }).sizeof(p.comp).? * 8;
const short_width = (Type{ .specifier = .short }).sizeof(p.comp).? * 8;
const int_width = (Type{ .specifier = .int }).sizeof(p.comp).? * 8;
if (e.num_negative_bits > 0) {
if (is_packed and e.num_negative_bits <= char_width and e.num_positive_bits < char_width) {
return .schar;
} else if (is_packed and e.num_negative_bits <= short_width and e.num_positive_bits < short_width) {
return .short;
} else if (e.num_negative_bits <= int_width and e.num_positive_bits < int_width) {
return .int;
}
const long_width = (Type{ .specifier = .long }).sizeof(p.comp).? * 8;
if (e.num_negative_bits <= long_width and e.num_positive_bits < long_width) {
return .long;
}
const long_long_width = (Type{ .specifier = .long_long }).sizeof(p.comp).? * 8;
if (e.num_negative_bits > long_long_width or e.num_positive_bits >= long_long_width) {
try p.errTok(.enum_too_large, tok);
}
return .long_long;
}
if (is_packed and e.num_positive_bits <= char_width) {
return .uchar;
} else if (is_packed and e.num_positive_bits <= short_width) {
return .ushort;
} else if (e.num_positive_bits <= int_width) {
return .uint;
} else if (e.num_positive_bits <= (Type{ .specifier = .long }).sizeof(p.comp).? * 8) {
return .ulong;
}
return .ulong_long;
}
};
const EnumFieldAndNode = struct { field: Type.Enum.Field, node: NodeIndex };
/// enumerator : IDENTIFIER ('=' integerConstExpr)
fn enumerator(p: *Parser, e: *Enumerator) Error!?EnumFieldAndNode {
_ = try p.pragma();
const name_tok = (try p.eatIdentifier()) orelse {
if (p.tok_ids[p.tok_i] == .r_brace) return null;
try p.err(.expected_identifier);
p.skipTo(.r_brace);
return error.ParsingFailed;
};
const attr_buf_top = p.attr_buf.len;
defer p.attr_buf.len = attr_buf_top;
try p.attributeSpecifier();
const err_start = p.comp.diagnostics.list.items.len;
if (p.eatToken(.equal)) |_| {
const specified = try p.integerConstExpr(.gnu_folding_extension);
if (specified.val.opt_ref == .none) {
try p.errTok(.enum_val_unavailable, name_tok + 2);
try e.incr(p, name_tok);
} else {
try e.set(p, specified, name_tok);
}
} else {
try e.incr(p, name_tok);
}
var res = e.res;
res.ty = try Attribute.applyEnumeratorAttributes(p, res.ty, attr_buf_top);
if (res.ty.isUnsignedInt(p.comp) or res.val.compare(.gte, Value.zero, p.comp)) {
e.num_positive_bits = @max(e.num_positive_bits, res.val.minUnsignedBits(p.comp));
} else {
e.num_negative_bits = @max(e.num_negative_bits, res.val.minSignedBits(p.comp));
}
if (err_start == p.comp.diagnostics.list.items.len) {
// only do these warnings if we didn't already warn about overflow or non-representable values
if (e.res.val.compare(.lt, Value.zero, p.comp)) {
const min_val = try Value.minInt(Type.int, p.comp);
if (e.res.val.compare(.lt, min_val, p.comp)) {
try p.errStr(.enumerator_too_small, name_tok, try e.res.str(p));
}
} else {
const max_val = try Value.maxInt(Type.int, p.comp);
if (e.res.val.compare(.gt, max_val, p.comp)) {
try p.errStr(.enumerator_too_large, name_tok, try e.res.str(p));
}
}
}
const interned_name = try StrInt.intern(p.comp, p.tokSlice(name_tok));
try p.syms.defineEnumeration(p, interned_name, res.ty, name_tok, e.res.val);
const node = try p.addNode(.{
.tag = .enum_field_decl,
.ty = res.ty,
.data = .{ .decl = .{
.name = name_tok,
.node = res.node,
} },
.loc = @enumFromInt(name_tok),
});
try p.value_map.put(node, e.res.val);
return EnumFieldAndNode{ .field = .{
.name = interned_name,
.ty = res.ty,
.name_tok = name_tok,
.node = res.node,
}, .node = node };
}
/// typeQual : keyword_const | keyword_restrict | keyword_volatile | keyword_atomic
fn typeQual(p: *Parser, b: *Type.Qualifiers.Builder) Error!bool {
var any = false;
while (true) {
switch (p.tok_ids[p.tok_i]) {
.keyword_restrict, .keyword_restrict1, .keyword_restrict2 => {
if (b.restrict != null)
try p.errStr(.duplicate_decl_spec, p.tok_i, "restrict")
else
b.restrict = p.tok_i;
},
.keyword_const, .keyword_const1, .keyword_const2 => {
if (b.@"const" != null)
try p.errStr(.duplicate_decl_spec, p.tok_i, "const")
else
b.@"const" = p.tok_i;
},
.keyword_volatile, .keyword_volatile1, .keyword_volatile2 => {
if (b.@"volatile" != null)
try p.errStr(.duplicate_decl_spec, p.tok_i, "volatile")
else
b.@"volatile" = p.tok_i;
},
.keyword_atomic => {
// _Atomic(typeName) instead of just _Atomic
if (p.tok_ids[p.tok_i + 1] == .l_paren) break;
if (b.atomic != null)
try p.errStr(.duplicate_decl_spec, p.tok_i, "atomic")
else
b.atomic = p.tok_i;
},
else => break,
}
p.tok_i += 1;
any = true;
}
return any;
}
const Declarator = struct {
name: TokenIndex,
ty: Type,
func_declarator: ?TokenIndex = null,
old_style_func: ?TokenIndex = null,
};
const DeclaratorKind = enum { normal, abstract, param, record };
/// declarator : pointer? (IDENTIFIER | '(' declarator ')') directDeclarator*
/// abstractDeclarator
/// : pointer? ('(' abstractDeclarator ')')? directAbstractDeclarator*
fn declarator(
p: *Parser,
base_type: Type,
kind: DeclaratorKind,
) Error!?Declarator {
const start = p.tok_i;
var d = Declarator{ .name = 0, .ty = try p.pointer(base_type) };
if (base_type.is(.auto_type) and !d.ty.is(.auto_type)) {
try p.errTok(.auto_type_requires_plain_declarator, start);
return error.ParsingFailed;
}
const maybe_ident = p.tok_i;
if (kind != .abstract and (try p.eatIdentifier()) != null) {
d.name = maybe_ident;
const combine_tok = p.tok_i;
d.ty = try p.directDeclarator(d.ty, &d, kind);
try d.ty.validateCombinedType(p, combine_tok);
return d;
} else if (p.eatToken(.l_paren)) |l_paren| blk: {
var res = (try p.declarator(.{ .specifier = .void }, kind)) orelse {
p.tok_i = l_paren;
break :blk;
};
try p.expectClosing(l_paren, .r_paren);
const suffix_start = p.tok_i;
const outer = try p.directDeclarator(d.ty, &d, kind);
try res.ty.combine(outer);
try res.ty.validateCombinedType(p, suffix_start);
res.old_style_func = d.old_style_func;
if (d.func_declarator) |some| res.func_declarator = some;
return res;
}
const expected_ident = p.tok_i;
d.ty = try p.directDeclarator(d.ty, &d, kind);
if (kind == .normal and !d.ty.isEnumOrRecord()) {
try p.errTok(.expected_ident_or_l_paren, expected_ident);
return error.ParsingFailed;
}
try d.ty.validateCombinedType(p, expected_ident);
if (start == p.tok_i) return null;
return d;
}
/// directDeclarator
/// : '[' typeQual* assignExpr? ']' directDeclarator?
/// | '[' keyword_static typeQual* assignExpr ']' directDeclarator?
/// | '[' typeQual+ keyword_static assignExpr ']' directDeclarator?
/// | '[' typeQual* '*' ']' directDeclarator?
/// | '(' paramDecls ')' directDeclarator?
/// | '(' (IDENTIFIER (',' IDENTIFIER))? ')' directDeclarator?
/// directAbstractDeclarator
/// : '[' typeQual* assignExpr? ']'
/// | '[' keyword_static typeQual* assignExpr ']'
/// | '[' typeQual+ keyword_static assignExpr ']'
/// | '[' '*' ']'
/// | '(' paramDecls? ')'
fn directDeclarator(p: *Parser, base_type: Type, d: *Declarator, kind: DeclaratorKind) Error!Type {
if (p.eatToken(.l_bracket)) |l_bracket| {
if (p.tok_ids[p.tok_i] == .l_bracket) {
switch (kind) {
.normal, .record => if (p.comp.langopts.standard.atLeast(.c23)) {
p.tok_i -= 1;
return base_type;
},
.param, .abstract => {},
}
try p.err(.expected_expr);
return error.ParsingFailed;
}
var res_ty = Type{
// so that we can get any restrict type that might be present
.specifier = .pointer,
};
var quals = Type.Qualifiers.Builder{};
var got_quals = try p.typeQual(&quals);
var static = p.eatToken(.keyword_static);
if (static != null and !got_quals) got_quals = try p.typeQual(&quals);
var star = p.eatToken(.asterisk);
const size_tok = p.tok_i;
const const_decl_folding = p.const_decl_folding;
p.const_decl_folding = .gnu_vla_folding_extension;
const size = if (star) |_| Result{} else try p.assignExpr();
p.const_decl_folding = const_decl_folding;
try p.expectClosing(l_bracket, .r_bracket);
if (star != null and static != null) {
try p.errTok(.invalid_static_star, static.?);
static = null;
}
if (kind != .param) {
if (static != null)
try p.errTok(.static_non_param, l_bracket)
else if (got_quals)
try p.errTok(.array_qualifiers, l_bracket);
if (star) |some| try p.errTok(.star_non_param, some);
static = null;
quals = .{};
star = null;
} else {
try quals.finish(p, &res_ty);
}
if (static) |_| try size.expect(p);
if (base_type.is(.auto_type)) {
try p.errStr(.array_of_auto_type, d.name, p.tokSlice(d.name));
return error.ParsingFailed;
}
const outer = try p.directDeclarator(base_type, d, kind);
if (!size.ty.isInt()) {
try p.errStr(.array_size_non_int, size_tok, try p.typeStr(size.ty));
return error.ParsingFailed;
}
if (base_type.is(.c23_auto) or outer.is(.invalid)) {
// issue error later
return Type.invalid;
} else if (size.val.opt_ref == .none) {
if (size.node != .none) {
try p.errTok(.vla, size_tok);
if (p.func.ty == null and kind != .param and p.record.kind == .invalid) {
try p.errTok(.variable_len_array_file_scope, d.name);
}
const expr_ty = try p.arena.create(Type.Expr);
expr_ty.ty = .{ .specifier = .void };
expr_ty.node = size.node;
res_ty.data = .{ .expr = expr_ty };
res_ty.specifier = .variable_len_array;
if (static) |some| try p.errTok(.useless_static, some);
} else if (star) |_| {
const elem_ty = try p.arena.create(Type);
elem_ty.* = .{ .specifier = .void };
res_ty.data = .{ .sub_type = elem_ty };
res_ty.specifier = .unspecified_variable_len_array;
} else {
const arr_ty = try p.arena.create(Type.Array);
arr_ty.elem = .{ .specifier = .void };
arr_ty.len = 0;
res_ty.data = .{ .array = arr_ty };
res_ty.specifier = .incomplete_array;
}
} else {
// `outer` is validated later so it may be invalid here
const outer_size = outer.sizeof(p.comp);
const max_elems = p.comp.maxArrayBytes() / @max(1, outer_size orelse 1);
var size_val = size.val;
if (size_val.isZero(p.comp)) {
try p.errTok(.zero_length_array, l_bracket);
} else if (size_val.compare(.lt, Value.zero, p.comp)) {
try p.errTok(.negative_array_size, l_bracket);
return error.ParsingFailed;
}
const arr_ty = try p.arena.create(Type.Array);
arr_ty.elem = .{ .specifier = .void };
arr_ty.len = size_val.toInt(u64, p.comp) orelse std.math.maxInt(u64);
if (arr_ty.len > max_elems) {
try p.errTok(.array_too_large, l_bracket);
arr_ty.len = max_elems;
}
res_ty.data = .{ .array = arr_ty };
res_ty.specifier = if (static != null) .static_array else .array;
}
try res_ty.combine(outer);
return res_ty;
} else if (p.eatToken(.l_paren)) |l_paren| {
d.func_declarator = l_paren;
const func_ty = try p.arena.create(Type.Func);
func_ty.params = &.{};
func_ty.return_type.specifier = .void;
var specifier: Type.Specifier = .func;
if (p.eatToken(.ellipsis)) |_| {
try p.err(.param_before_var_args);
try p.expectClosing(l_paren, .r_paren);
var res_ty = Type{ .specifier = .func, .data = .{ .func = func_ty } };
const outer = try p.directDeclarator(base_type, d, kind);
try res_ty.combine(outer);
return res_ty;
}
if (try p.paramDecls(d)) |params| {
func_ty.params = params;
if (p.eatToken(.ellipsis)) |_| specifier = .var_args_func;
} else if (p.tok_ids[p.tok_i] == .r_paren) {
specifier = if (p.comp.langopts.standard.atLeast(.c23))
.func
else
.old_style_func;
} else if (p.tok_ids[p.tok_i] == .identifier or p.tok_ids[p.tok_i] == .extended_identifier) {
d.old_style_func = p.tok_i;
const param_buf_top = p.param_buf.items.len;
try p.syms.pushScope(p);
defer {
p.param_buf.items.len = param_buf_top;
p.syms.popScope();
}
specifier = .old_style_func;
while (true) {
const name_tok = try p.expectIdentifier();
const interned_name = try StrInt.intern(p.comp, p.tokSlice(name_tok));
try p.syms.defineParam(p, interned_name, undefined, name_tok);
try p.param_buf.append(.{
.name = interned_name,
.name_tok = name_tok,
.ty = .{ .specifier = .int },
});
if (p.eatToken(.comma) == null) break;
}
func_ty.params = try p.arena.dupe(Type.Func.Param, p.param_buf.items[param_buf_top..]);
} else {
try p.err(.expected_param_decl);
}
try p.expectClosing(l_paren, .r_paren);
var res_ty = Type{
.specifier = specifier,
.data = .{ .func = func_ty },
};
const outer = try p.directDeclarator(base_type, d, kind);
try res_ty.combine(outer);
return res_ty;
} else return base_type;
}
/// pointer : '*' typeQual* pointer?
fn pointer(p: *Parser, base_ty: Type) Error!Type {
var ty = base_ty;
while (p.eatToken(.asterisk)) |_| {
if (!ty.is(.invalid)) {
const elem_ty = try p.arena.create(Type);
elem_ty.* = ty;
ty = Type{
.specifier = .pointer,
.data = .{ .sub_type = elem_ty },
};
}
var quals = Type.Qualifiers.Builder{};
_ = try p.typeQual(&quals);
try quals.finish(p, &ty);
}
return ty;
}
/// paramDecls : paramDecl (',' paramDecl)* (',' '...')
/// paramDecl : declSpec (declarator | abstractDeclarator)
fn paramDecls(p: *Parser, d: *Declarator) Error!?[]Type.Func.Param {
// TODO warn about visibility of types declared here
const param_buf_top = p.param_buf.items.len;
defer p.param_buf.items.len = param_buf_top;
try p.syms.pushScope(p);
defer p.syms.popScope();
while (true) {
const attr_buf_top = p.attr_buf.len;
defer p.attr_buf.len = attr_buf_top;
const param_decl_spec = if (try p.declSpec()) |some|
some
else if (p.comp.langopts.standard.atLeast(.c23) and
(p.tok_ids[p.tok_i] == .identifier or p.tok_ids[p.tok_i] == .extended_identifier))
{
// handle deprecated K&R style parameters
const identifier = try p.expectIdentifier();
try p.errStr(.unknown_type_name, identifier, p.tokSlice(identifier));
if (d.old_style_func == null) d.old_style_func = identifier;
try p.param_buf.append(.{
.name = try StrInt.intern(p.comp, p.tokSlice(identifier)),
.name_tok = identifier,
.ty = .{ .specifier = .int },
});
if (p.eatToken(.comma) == null) break;
if (p.tok_ids[p.tok_i] == .ellipsis) break;
continue;
} else if (p.param_buf.items.len == param_buf_top) {
return null;
} else blk: {
var spec: Type.Builder = .{};
break :blk DeclSpec{ .ty = try spec.finish(p) };
};
var name_tok: TokenIndex = 0;
const first_tok = p.tok_i;
var param_ty = param_decl_spec.ty;
if (try p.declarator(param_decl_spec.ty, .param)) |some| {
if (some.old_style_func) |tok_i| try p.errTok(.invalid_old_style_params, tok_i);
try p.attributeSpecifier();
name_tok = some.name;
param_ty = some.ty;
if (some.name != 0) {
const interned_name = try StrInt.intern(p.comp, p.tokSlice(name_tok));
try p.syms.defineParam(p, interned_name, param_ty, name_tok);
}
}
param_ty = try Attribute.applyParameterAttributes(p, param_ty, attr_buf_top, .alignas_on_param);
if (param_ty.isFunc()) {
// params declared as functions are converted to function pointers
const elem_ty = try p.arena.create(Type);
elem_ty.* = param_ty;
param_ty = Type{
.specifier = .pointer,
.data = .{ .sub_type = elem_ty },
};
} else if (param_ty.isArray()) {
// params declared as arrays are converted to pointers
param_ty.decayArray();
} else if (param_ty.is(.void)) {
// validate void parameters
if (p.param_buf.items.len == param_buf_top) {
if (p.tok_ids[p.tok_i] != .r_paren) {
try p.err(.void_only_param);
if (param_ty.anyQual()) try p.err(.void_param_qualified);
return error.ParsingFailed;
}
return &[0]Type.Func.Param{};
}
try p.err(.void_must_be_first_param);
return error.ParsingFailed;
}
try param_decl_spec.validateParam(p, ¶m_ty);
try p.param_buf.append(.{
.name = if (name_tok == 0) .empty else try StrInt.intern(p.comp, p.tokSlice(name_tok)),
.name_tok = if (name_tok == 0) first_tok else name_tok,
.ty = param_ty,
});
if (p.eatToken(.comma) == null) break;
if (p.tok_ids[p.tok_i] == .ellipsis) break;
}
return try p.arena.dupe(Type.Func.Param, p.param_buf.items[param_buf_top..]);
}
/// typeName : specQual abstractDeclarator
fn typeName(p: *Parser) Error!?Type {
const attr_buf_top = p.attr_buf.len;
defer p.attr_buf.len = attr_buf_top;
const ty = (try p.specQual()) orelse return null;
if (try p.declarator(ty, .abstract)) |some| {
if (some.old_style_func) |tok_i| try p.errTok(.invalid_old_style_params, tok_i);
return try Attribute.applyTypeAttributes(p, some.ty, attr_buf_top, .align_ignored);
}
return try Attribute.applyTypeAttributes(p, ty, attr_buf_top, .align_ignored);
}
fn complexInitializer(p: *Parser, init_ty: Type) Error!Result {
assert(p.tok_ids[p.tok_i] == .l_brace);
assert(init_ty.isComplex());
const real_ty = init_ty.makeReal();
if (real_ty.isInt()) {
return p.todo("Complex integer initializers");
}
const l_brace = p.tok_i;
p.tok_i += 1;
try p.errTok(.complex_component_init, l_brace);
const first_tok = p.tok_i;
var first = try p.assignExpr();
try first.expect(p);
try p.coerceInit(&first, first_tok, real_ty);
var second: Result = .{
.ty = real_ty,
.val = Value.zero,
};
if (p.eatToken(.comma)) |_| {
const second_tok = p.tok_i;
const maybe_second = try p.assignExpr();
if (!maybe_second.empty(p)) {
second = maybe_second;
try p.coerceInit(&second, second_tok, real_ty);
}
}
// Eat excess initializers
var extra_tok: ?TokenIndex = null;
while (p.eatToken(.comma)) |_| {
if (p.tok_ids[p.tok_i] == .r_brace) break;
extra_tok = p.tok_i;
const extra = try p.assignExpr();
if (extra.empty(p)) {
try p.errTok(.expected_expr, p.tok_i);
p.skipTo(.r_brace);
return error.ParsingFailed;
}
}
try p.expectClosing(l_brace, .r_brace);
if (extra_tok) |tok| {
try p.errTok(.excess_scalar_init, tok);
}
const arr_init_node: Tree.Node = .{
.tag = .array_init_expr_two,
.ty = init_ty,
.data = .{ .two = .{ first.node, second.node } },
.loc = @enumFromInt(l_brace),
};
var res: Result = .{
.node = try p.addNode(arr_init_node),
.ty = init_ty,
};
if (first.val.opt_ref != .none and second.val.opt_ref != .none) {
res.val = try Value.intern(p.comp, switch (real_ty.bitSizeof(p.comp).?) {
32 => .{ .complex = .{ .cf32 = .{ first.val.toFloat(f32, p.comp), second.val.toFloat(f32, p.comp) } } },
64 => .{ .complex = .{ .cf64 = .{ first.val.toFloat(f64, p.comp), second.val.toFloat(f64, p.comp) } } },
80 => .{ .complex = .{ .cf80 = .{ first.val.toFloat(f80, p.comp), second.val.toFloat(f80, p.comp) } } },
128 => .{ .complex = .{ .cf128 = .{ first.val.toFloat(f128, p.comp), second.val.toFloat(f128, p.comp) } } },
else => unreachable,
});
}
return res;
}
/// initializer
/// : assignExpr
/// | '{' initializerItems '}'
fn initializer(p: *Parser, init_ty: Type) Error!Result {
// fast path for non-braced initializers
if (p.tok_ids[p.tok_i] != .l_brace) {
const tok = p.tok_i;
var res = try p.assignExpr();
try res.expect(p);
if (try p.coerceArrayInit(&res, tok, init_ty)) return res;
try p.coerceInit(&res, tok, init_ty);
return res;
}
if (init_ty.is(.auto_type)) {
try p.err(.auto_type_with_init_list);
return error.ParsingFailed;
}
if (init_ty.isComplex()) {
return p.complexInitializer(init_ty);
}
var il: InitList = .{};
defer il.deinit(p.gpa);
_ = try p.initializerItem(&il, init_ty);
const res = try p.convertInitList(il, init_ty);
var res_ty = p.nodes.items(.ty)[@intFromEnum(res)];
res_ty.qual = init_ty.qual;
return Result{ .ty = res_ty, .node = res };
}
/// initializerItems : designation? initializer (',' designation? initializer)* ','?
/// designation : designator+ '='
/// designator
/// : '[' integerConstExpr ']'
/// | '.' identifier
fn initializerItem(p: *Parser, il: *InitList, init_ty: Type) Error!bool {
const l_brace = p.eatToken(.l_brace) orelse {
const tok = p.tok_i;
var res = try p.assignExpr();
if (res.empty(p)) return false;
const arr = try p.coerceArrayInit(&res, tok, init_ty);
if (!arr) try p.coerceInit(&res, tok, init_ty);
if (il.tok != 0) {
try p.errTok(.initializer_overrides, tok);
try p.errTok(.previous_initializer, il.tok);
}
il.node = res.node;
il.tok = tok;
return true;
};
const is_scalar = init_ty.isScalar();
const is_complex = init_ty.isComplex();
const scalar_inits_needed: usize = if (is_complex) 2 else 1;
if (p.eatToken(.r_brace)) |_| {
if (is_scalar) try p.errTok(.empty_scalar_init, l_brace);
if (il.tok != 0) {
try p.errTok(.initializer_overrides, l_brace);
try p.errTok(.previous_initializer, il.tok);
}
il.node = .none;
il.tok = l_brace;
return true;
}
var count: u64 = 0;
var warned_excess = false;
var is_str_init = false;
var index_hint: ?u64 = null;
while (true) : (count += 1) {
errdefer p.skipTo(.r_brace);
var first_tok = p.tok_i;
var cur_ty = init_ty;
var cur_il = il;
var designation = false;
var cur_index_hint: ?u64 = null;
while (true) {
if (p.eatToken(.l_bracket)) |l_bracket| {
if (!cur_ty.isArray()) {
try p.errStr(.invalid_array_designator, l_bracket, try p.typeStr(cur_ty));
return error.ParsingFailed;
}
const expr_tok = p.tok_i;
const index_res = try p.integerConstExpr(.gnu_folding_extension);
try p.expectClosing(l_bracket, .r_bracket);
if (index_res.val.opt_ref == .none) {
try p.errTok(.expected_integer_constant_expr, expr_tok);
return error.ParsingFailed;
} else if (index_res.val.compare(.lt, Value.zero, p.comp)) {
try p.errStr(.negative_array_designator, l_bracket + 1, try index_res.str(p));
return error.ParsingFailed;
}
const max_len = cur_ty.arrayLen() orelse std.math.maxInt(usize);
const index_int = index_res.val.toInt(u64, p.comp) orelse std.math.maxInt(u64);
if (index_int >= max_len) {
try p.errStr(.oob_array_designator, l_bracket + 1, try index_res.str(p));
return error.ParsingFailed;
}
cur_index_hint = cur_index_hint orelse index_int;
cur_il = try cur_il.find(p.gpa, index_int);
cur_ty = cur_ty.elemType();
designation = true;
} else if (p.eatToken(.period)) |period| {
const field_tok = try p.expectIdentifier();
const field_str = p.tokSlice(field_tok);
const field_name = try StrInt.intern(p.comp, field_str);
cur_ty = cur_ty.canonicalize(.standard);
if (!cur_ty.isRecord()) {
try p.errStr(.invalid_field_designator, period, try p.typeStr(cur_ty));
return error.ParsingFailed;
} else if (!cur_ty.hasField(field_name)) {
try p.errStr(.no_such_field_designator, period, field_str);
return error.ParsingFailed;
}
// TODO check if union already has field set
outer: while (true) {
for (cur_ty.data.record.fields, 0..) |f, i| {
if (f.isAnonymousRecord()) {
// Recurse into anonymous field if it has a field by the name.
if (!f.ty.hasField(field_name)) continue;
cur_ty = f.ty.canonicalize(.standard);
cur_il = try il.find(p.gpa, i);
cur_index_hint = cur_index_hint orelse i;
continue :outer;
}
if (field_name == f.name) {
cur_il = try cur_il.find(p.gpa, i);
cur_ty = f.ty;
cur_index_hint = cur_index_hint orelse i;
break :outer;
}
}
unreachable; // we already checked that the starting type has this field
}
designation = true;
} else break;
}
if (designation) index_hint = null;
defer index_hint = cur_index_hint orelse null;
if (designation) _ = try p.expectToken(.equal);
if (!designation and cur_ty.hasAttribute(.designated_init)) {
try p.err(.designated_init_needed);
}
var saw = false;
if (is_str_init and p.isStringInit(init_ty)) {
// discard further strings
var tmp_il = InitList{};
defer tmp_il.deinit(p.gpa);
saw = try p.initializerItem(&tmp_il, .{ .specifier = .void });
} else if (count == 0 and p.isStringInit(init_ty)) {
is_str_init = true;
saw = try p.initializerItem(il, init_ty);
} else if (is_scalar and count >= scalar_inits_needed) {
// discard further scalars
var tmp_il = InitList{};
defer tmp_il.deinit(p.gpa);
saw = try p.initializerItem(&tmp_il, .{ .specifier = .void });
} else if (p.tok_ids[p.tok_i] == .l_brace) {
if (designation) {
// designation overrides previous value, let existing mechanism handle it
saw = try p.initializerItem(cur_il, cur_ty);
} else if (try p.findAggregateInitializer(&cur_il, &cur_ty, &index_hint)) {
saw = try p.initializerItem(cur_il, cur_ty);
} else {
// discard further values
var tmp_il = InitList{};
defer tmp_il.deinit(p.gpa);
saw = try p.initializerItem(&tmp_il, .{ .specifier = .void });
if (!warned_excess) try p.errTok(if (init_ty.isArray()) .excess_array_init else .excess_struct_init, first_tok);
warned_excess = true;
}
} else single_item: {
first_tok = p.tok_i;
var res = try p.assignExpr();
saw = !res.empty(p);
if (!saw) break :single_item;
excess: {
if (index_hint) |*hint| {
if (try p.findScalarInitializerAt(&cur_il, &cur_ty, &res, first_tok, hint)) break :excess;
} else if (try p.findScalarInitializer(&cur_il, &cur_ty, &res, first_tok)) break :excess;
if (designation) break :excess;
if (!warned_excess) try p.errTok(if (init_ty.isArray()) .excess_array_init else .excess_struct_init, first_tok);
warned_excess = true;
break :single_item;
}
const arr = try p.coerceArrayInit(&res, first_tok, cur_ty);
if (!arr) try p.coerceInit(&res, first_tok, cur_ty);
if (cur_il.tok != 0) {
try p.errTok(.initializer_overrides, first_tok);
try p.errTok(.previous_initializer, cur_il.tok);
}
cur_il.node = res.node;
cur_il.tok = first_tok;
}
if (!saw) {
if (designation) {
try p.err(.expected_expr);
return error.ParsingFailed;
}
break;
} else if (count == 1) {
if (is_str_init) try p.errTok(.excess_str_init, first_tok);
if (is_scalar and !is_complex) try p.errTok(.excess_scalar_init, first_tok);
} else if (count == 2) {
if (is_scalar and is_complex) try p.errTok(.excess_scalar_init, first_tok);
}
if (p.eatToken(.comma) == null) break;
}
try p.expectClosing(l_brace, .r_brace);
if (is_complex and count == 1) { // count of 1 means we saw exactly 2 items in the initializer list
try p.errTok(.complex_component_init, l_brace);
}
if (is_scalar or is_str_init) return true;
if (il.tok != 0) {
try p.errTok(.initializer_overrides, l_brace);
try p.errTok(.previous_initializer, il.tok);
}
il.node = .none;
il.tok = l_brace;
return true;
}
/// Returns true if the value is unused.
fn findScalarInitializerAt(p: *Parser, il: **InitList, ty: *Type, res: *Result, first_tok: TokenIndex, start_index: *u64) Error!bool {
if (ty.isArray()) {
if (il.*.node != .none) return false;
start_index.* += 1;
const arr_ty = ty.*;
const elem_count = arr_ty.arrayLen() orelse std.math.maxInt(u64);
if (elem_count == 0) {
try p.errTok(.empty_aggregate_init_braces, first_tok);
return error.ParsingFailed;
}
const elem_ty = arr_ty.elemType();
const arr_il = il.*;
if (start_index.* < elem_count) {
ty.* = elem_ty;
il.* = try arr_il.find(p.gpa, start_index.*);
_ = try p.findScalarInitializer(il, ty, res, first_tok);
return true;
}
return false;
} else if (ty.get(.@"struct")) |struct_ty| {
if (il.*.node != .none) return false;
start_index.* += 1;
const fields = struct_ty.data.record.fields;
if (fields.len == 0) {
try p.errTok(.empty_aggregate_init_braces, first_tok);
return error.ParsingFailed;
}
const struct_il = il.*;
if (start_index.* < fields.len) {
const field = fields[@intCast(start_index.*)];
ty.* = field.ty;
il.* = try struct_il.find(p.gpa, start_index.*);
_ = try p.findScalarInitializer(il, ty, res, first_tok);
return true;
}
return false;
} else if (ty.get(.@"union")) |_| {
return false;
}
return il.*.node == .none;
}
/// Returns true if the value is unused.
fn findScalarInitializer(p: *Parser, il: **InitList, ty: *Type, res: *Result, first_tok: TokenIndex) Error!bool {
const actual_ty = res.ty;
if (ty.isArray() or ty.isComplex()) {
if (il.*.node != .none) return false;
if (try p.coerceArrayInitExtra(res, first_tok, ty.*, false)) return true;
const start_index = il.*.list.items.len;
var index = if (start_index != 0) il.*.list.items[start_index - 1].index else start_index;
const arr_ty = ty.*;
const elem_count: u64 = arr_ty.expectedInitListSize() orelse std.math.maxInt(u64);
if (elem_count == 0) {
try p.errTok(.empty_aggregate_init_braces, first_tok);
return error.ParsingFailed;
}
const elem_ty = arr_ty.elemType();
const arr_il = il.*;
while (index < elem_count) : (index += 1) {
ty.* = elem_ty;
il.* = try arr_il.find(p.gpa, index);
if (il.*.node == .none and actual_ty.eql(elem_ty, p.comp, false)) return true;
if (try p.findScalarInitializer(il, ty, res, first_tok)) return true;
}
return false;
} else if (ty.get(.@"struct")) |struct_ty| {
if (il.*.node != .none) return false;
if (actual_ty.eql(ty.*, p.comp, false)) return true;
const start_index = il.*.list.items.len;
var index = if (start_index != 0) il.*.list.items[start_index - 1].index + 1 else start_index;
const fields = struct_ty.data.record.fields;
if (fields.len == 0) {
try p.errTok(.empty_aggregate_init_braces, first_tok);
return error.ParsingFailed;
}
const struct_il = il.*;
while (index < fields.len) : (index += 1) {
const field = fields[@intCast(index)];
ty.* = field.ty;
il.* = try struct_il.find(p.gpa, index);
if (il.*.node == .none and actual_ty.eql(field.ty, p.comp, false)) return true;
if (il.*.node == .none and try p.coerceArrayInitExtra(res, first_tok, ty.*, false)) return true;
if (try p.findScalarInitializer(il, ty, res, first_tok)) return true;
}
return false;
} else if (ty.get(.@"union")) |union_ty| {
if (il.*.node != .none) return false;
if (actual_ty.eql(ty.*, p.comp, false)) return true;
if (union_ty.data.record.fields.len == 0) {
try p.errTok(.empty_aggregate_init_braces, first_tok);
return error.ParsingFailed;
}
ty.* = union_ty.data.record.fields[0].ty;
il.* = try il.*.find(p.gpa, 0);
// if (il.*.node == .none and actual_ty.eql(ty, p.comp, false)) return true;
if (try p.coerceArrayInitExtra(res, first_tok, ty.*, false)) return true;
if (try p.findScalarInitializer(il, ty, res, first_tok)) return true;
return false;
}
return il.*.node == .none;
}
fn findAggregateInitializer(p: *Parser, il: **InitList, ty: *Type, start_index: *?u64) Error!bool {
if (ty.isArray()) {
if (il.*.node != .none) return false;
const list_index = il.*.list.items.len;
const index = if (start_index.*) |*some| blk: {
some.* += 1;
break :blk some.*;
} else if (list_index != 0)
il.*.list.items[list_index - 1].index + 1
else
list_index;
const arr_ty = ty.*;
const elem_count = arr_ty.arrayLen() orelse std.math.maxInt(u64);
const elem_ty = arr_ty.elemType();
if (index < elem_count) {
ty.* = elem_ty;
il.* = try il.*.find(p.gpa, index);
return true;
}
return false;
} else if (ty.get(.@"struct")) |struct_ty| {
if (il.*.node != .none) return false;
const list_index = il.*.list.items.len;
const index = if (start_index.*) |*some| blk: {
some.* += 1;
break :blk some.*;
} else if (list_index != 0)
il.*.list.items[list_index - 1].index + 1
else
list_index;
const field_count = struct_ty.data.record.fields.len;
if (index < field_count) {
ty.* = struct_ty.data.record.fields[@intCast(index)].ty;
il.* = try il.*.find(p.gpa, index);
return true;
}
return false;
} else if (ty.get(.@"union")) |union_ty| {
if (il.*.node != .none) return false;
if (start_index.*) |_| return false; // overrides
if (union_ty.data.record.fields.len == 0) return false;
ty.* = union_ty.data.record.fields[0].ty;
il.* = try il.*.find(p.gpa, 0);
return true;
} else {
try p.err(.too_many_scalar_init_braces);
return il.*.node == .none;
}
}
fn coerceArrayInit(p: *Parser, item: *Result, tok: TokenIndex, target: Type) !bool {
return p.coerceArrayInitExtra(item, tok, target, true);
}
fn coerceArrayInitExtra(p: *Parser, item: *Result, tok: TokenIndex, target: Type, report_err: bool) !bool {
if (!target.isArray()) return false;
const is_str_lit = p.nodeIs(item.node, .string_literal_expr);
if (!is_str_lit and !p.nodeIsCompoundLiteral(item.node) or !item.ty.isArray()) {
if (!report_err) return false;
try p.errTok(.array_init_str, tok);
return true; // do not do further coercion
}
const target_spec = target.elemType().canonicalize(.standard).specifier;
const item_spec = item.ty.elemType().canonicalize(.standard).specifier;
const compatible = target.elemType().eql(item.ty.elemType(), p.comp, false) or
(is_str_lit and item_spec == .char and (target_spec == .uchar or target_spec == .schar)) or
(is_str_lit and item_spec == .uchar and (target_spec == .uchar or target_spec == .schar or target_spec == .char));
if (!compatible) {
if (!report_err) return false;
const e_msg = " with array of type ";
try p.errStr(.incompatible_array_init, tok, try p.typePairStrExtra(target, e_msg, item.ty));
return true; // do not do further coercion
}
if (target.get(.array)) |arr_ty| {
assert(item.ty.specifier == .array);
const len = item.ty.arrayLen().?;
const array_len = arr_ty.arrayLen().?;
if (is_str_lit) {
// the null byte of a string can be dropped
if (len - 1 > array_len and report_err) {
try p.errTok(.str_init_too_long, tok);
}
} else if (len > array_len and report_err) {
try p.errStr(
.arr_init_too_long,
tok,
try p.typePairStrExtra(target, " with array of type ", item.ty),
);
}
}
return true;
}
fn coerceInit(p: *Parser, item: *Result, tok: TokenIndex, target: Type) !void {
if (target.is(.void)) return; // Do not do type coercion on excess items
const node = item.node;
try item.lvalConversion(p);
if (target.is(.auto_type)) {
if (p.getNode(node, .member_access_expr) orelse p.getNode(node, .member_access_ptr_expr)) |member_node| {
if (p.tmpTree().isBitfield(member_node)) try p.errTok(.auto_type_from_bitfield, tok);
}
return;
} else if (target.is(.c23_auto)) {
return;
}
try item.coerce(p, target, tok, .init);
}
fn isStringInit(p: *Parser, ty: Type) bool {
if (!ty.isArray() or !ty.elemType().isInt()) return false;
var i = p.tok_i;
while (true) : (i += 1) {
switch (p.tok_ids[i]) {
.l_paren => {},
.string_literal,
.string_literal_utf_16,
.string_literal_utf_8,
.string_literal_utf_32,
.string_literal_wide,
=> return true,
else => return false,
}
}
}
/// Convert InitList into an AST
fn convertInitList(p: *Parser, il: InitList, init_ty: Type) Error!NodeIndex {
const is_complex = init_ty.isComplex();
if (init_ty.isScalar() and !is_complex) {
if (il.node == .none) {
return p.addNode(.{ .tag = .default_init_expr, .ty = init_ty, .data = undefined });
}
return il.node;
} else if (init_ty.is(.variable_len_array)) {
return error.ParsingFailed; // vla invalid, reported earlier
} else if (init_ty.isArray() or is_complex) {
if (il.node != .none) {
return il.node;
}
const list_buf_top = p.list_buf.items.len;
defer p.list_buf.items.len = list_buf_top;
const elem_ty = init_ty.elemType();
const max_items: u64 = init_ty.expectedInitListSize() orelse std.math.maxInt(usize);
var start: u64 = 0;
for (il.list.items) |*init| {
if (init.index > start) {
const elem = try p.addNode(.{
.tag = .array_filler_expr,
.ty = elem_ty,
.data = .{ .int = init.index - start },
});
try p.list_buf.append(elem);
}
start = init.index + 1;
const elem = try p.convertInitList(init.list, elem_ty);
try p.list_buf.append(elem);
}
var arr_init_node: Tree.Node = .{
.tag = .array_init_expr_two,
.ty = init_ty,
.data = .{ .two = .{ .none, .none } },
};
const max_elems = p.comp.maxArrayBytes() / (@max(1, elem_ty.sizeof(p.comp) orelse 1));
if (start > max_elems) {
try p.errTok(.array_too_large, il.tok);
start = max_elems;
}
if (init_ty.specifier == .incomplete_array) {
arr_init_node.ty.specifier = .array;
arr_init_node.ty.data.array.len = start;
} else if (init_ty.is(.incomplete_array)) {
const arr_ty = try p.arena.create(Type.Array);
arr_ty.* = .{ .elem = init_ty.elemType(), .len = start };
arr_init_node.ty = .{
.specifier = .array,
.data = .{ .array = arr_ty },
};
const attrs = init_ty.getAttributes();
arr_init_node.ty = try arr_init_node.ty.withAttributes(p.arena, attrs);
} else if (start < max_items) {
const elem = try p.addNode(.{
.tag = .array_filler_expr,
.ty = elem_ty,
.data = .{ .int = max_items - start },
});
try p.list_buf.append(elem);
}
const items = p.list_buf.items[list_buf_top..];
switch (items.len) {
0 => {},
1 => arr_init_node.data.two[0] = items[0],
2 => arr_init_node.data.two = .{ items[0], items[1] },
else => {
arr_init_node.tag = .array_init_expr;
arr_init_node.data = .{ .range = try p.addList(items) };
},
}
return try p.addNode(arr_init_node);
} else if (init_ty.get(.@"struct")) |struct_ty| {
assert(!struct_ty.hasIncompleteSize());
if (il.node != .none) {
return il.node;
}
const list_buf_top = p.list_buf.items.len;
defer p.list_buf.items.len = list_buf_top;
var init_index: usize = 0;
for (struct_ty.data.record.fields, 0..) |f, i| {
if (init_index < il.list.items.len and il.list.items[init_index].index == i) {
const item = try p.convertInitList(il.list.items[init_index].list, f.ty);
try p.list_buf.append(item);
init_index += 1;
} else {
const item = try p.addNode(.{ .tag = .default_init_expr, .ty = f.ty, .data = undefined });
try p.list_buf.append(item);
}
}
var struct_init_node: Tree.Node = .{
.tag = .struct_init_expr_two,
.ty = init_ty,
.data = .{ .two = .{ .none, .none } },
};
const items = p.list_buf.items[list_buf_top..];
switch (items.len) {
0 => {},
1 => struct_init_node.data.two[0] = items[0],
2 => struct_init_node.data.two = .{ items[0], items[1] },
else => {
struct_init_node.tag = .struct_init_expr;
struct_init_node.data = .{ .range = try p.addList(items) };
},
}
return try p.addNode(struct_init_node);
} else if (init_ty.get(.@"union")) |union_ty| {
if (il.node != .none) {
return il.node;
}
var union_init_node: Tree.Node = .{
.tag = .union_init_expr,
.ty = init_ty,
.data = .{ .union_init = .{ .field_index = 0, .node = .none } },
};
if (union_ty.data.record.fields.len == 0) {
// do nothing for empty unions
} else if (il.list.items.len == 0) {
union_init_node.data.union_init.node = try p.addNode(.{
.tag = .default_init_expr,
.ty = init_ty,
.data = undefined,
});
} else {
const init = il.list.items[0];
const index: u32 = @truncate(init.index);
const field_ty = union_ty.data.record.fields[index].ty;
union_init_node.data.union_init = .{
.field_index = index,
.node = try p.convertInitList(init.list, field_ty),
};
}
return try p.addNode(union_init_node);
} else {
return error.ParsingFailed; // initializer target is invalid, reported earlier
}
}
fn msvcAsmStmt(p: *Parser) Error!?NodeIndex {
return p.todo("MSVC assembly statements");
}
/// asmOperand : ('[' IDENTIFIER ']')? asmStr '(' expr ')'
fn asmOperand(p: *Parser, names: *std.ArrayList(?TokenIndex), constraints: *NodeList, exprs: *NodeList) Error!void {
if (p.eatToken(.l_bracket)) |l_bracket| {
const ident = (try p.eatIdentifier()) orelse {
try p.err(.expected_identifier);
return error.ParsingFailed;
};
try names.append(ident);
try p.expectClosing(l_bracket, .r_bracket);
} else {
try names.append(null);
}
const constraint = try p.asmStr();
try constraints.append(constraint.node);
const l_paren = p.eatToken(.l_paren) orelse {
try p.errExtra(.expected_token, p.tok_i, .{ .tok_id = .{ .actual = p.tok_ids[p.tok_i], .expected = .l_paren } });
return error.ParsingFailed;
};
const res = try p.expr();
try p.expectClosing(l_paren, .r_paren);
try res.expect(p);
try exprs.append(res.node);
}
/// gnuAsmStmt
/// : asmStr
/// | asmStr ':' asmOperand*
/// | asmStr ':' asmOperand* ':' asmOperand*
/// | asmStr ':' asmOperand* ':' asmOperand* : asmStr? (',' asmStr)*
/// | asmStr ':' asmOperand* ':' asmOperand* : asmStr? (',' asmStr)* : IDENTIFIER (',' IDENTIFIER)*
fn gnuAsmStmt(p: *Parser, quals: Tree.GNUAssemblyQualifiers, asm_tok: TokenIndex, l_paren: TokenIndex) Error!NodeIndex {
const asm_str = try p.asmStr();
try p.checkAsmStr(asm_str.val, l_paren);
if (p.tok_ids[p.tok_i] == .r_paren) {
return p.addNode(.{
.tag = .gnu_asm_simple,
.ty = .{ .specifier = .void },
.data = .{ .un = asm_str.node },
.loc = @enumFromInt(asm_tok),
});
}
const expected_items = 8; // arbitrarily chosen, most assembly will have fewer than 8 inputs/outputs/constraints/names
const bytes_needed = expected_items * @sizeOf(?TokenIndex) + expected_items * 3 * @sizeOf(NodeIndex);
var stack_fallback = std.heap.stackFallback(bytes_needed, p.gpa);
const allocator = stack_fallback.get();
// TODO: Consider using a TokenIndex of 0 instead of null if we need to store the names in the tree
var names = std.ArrayList(?TokenIndex).initCapacity(allocator, expected_items) catch unreachable; // stack allocation already succeeded
defer names.deinit();
var constraints = NodeList.initCapacity(allocator, expected_items) catch unreachable; // stack allocation already succeeded
defer constraints.deinit();
var exprs = NodeList.initCapacity(allocator, expected_items) catch unreachable; //stack allocation already succeeded
defer exprs.deinit();
var clobbers = NodeList.initCapacity(allocator, expected_items) catch unreachable; //stack allocation already succeeded
defer clobbers.deinit();
// Outputs
var ate_extra_colon = false;
if (p.eatToken(.colon) orelse p.eatToken(.colon_colon)) |tok_i| {
ate_extra_colon = p.tok_ids[tok_i] == .colon_colon;
if (!ate_extra_colon) {
if (p.tok_ids[p.tok_i].isStringLiteral() or p.tok_ids[p.tok_i] == .l_bracket) {
while (true) {
try p.asmOperand(&names, &constraints, &exprs);
if (p.eatToken(.comma) == null) break;
}
}
}
}
const num_outputs = names.items.len;
// Inputs
if (ate_extra_colon or p.tok_ids[p.tok_i] == .colon or p.tok_ids[p.tok_i] == .colon_colon) {
if (ate_extra_colon) {
ate_extra_colon = false;
} else {
ate_extra_colon = p.tok_ids[p.tok_i] == .colon_colon;
p.tok_i += 1;
}
if (!ate_extra_colon) {
if (p.tok_ids[p.tok_i].isStringLiteral() or p.tok_ids[p.tok_i] == .l_bracket) {
while (true) {
try p.asmOperand(&names, &constraints, &exprs);
if (p.eatToken(.comma) == null) break;
}
}
}
}
std.debug.assert(names.items.len == constraints.items.len and constraints.items.len == exprs.items.len);
const num_inputs = names.items.len - num_outputs;
_ = num_inputs;
// Clobbers
if (ate_extra_colon or p.tok_ids[p.tok_i] == .colon or p.tok_ids[p.tok_i] == .colon_colon) {
if (ate_extra_colon) {
ate_extra_colon = false;
} else {
ate_extra_colon = p.tok_ids[p.tok_i] == .colon_colon;
p.tok_i += 1;
}
if (!ate_extra_colon and p.tok_ids[p.tok_i].isStringLiteral()) {
while (true) {
const clobber = try p.asmStr();
try clobbers.append(clobber.node);
if (p.eatToken(.comma) == null) break;
}
}
}
if (!quals.goto and (p.tok_ids[p.tok_i] != .r_paren or ate_extra_colon)) {
try p.errExtra(.expected_token, p.tok_i, .{ .tok_id = .{ .actual = p.tok_ids[p.tok_i], .expected = .r_paren } });
return error.ParsingFailed;
}
// Goto labels
var num_labels: u32 = 0;
if (ate_extra_colon or p.tok_ids[p.tok_i] == .colon) {
if (!ate_extra_colon) {
p.tok_i += 1;
}
while (true) {
const ident = (try p.eatIdentifier()) orelse {
try p.err(.expected_identifier);
return error.ParsingFailed;
};
const ident_str = p.tokSlice(ident);
const label = p.findLabel(ident_str) orelse blk: {
try p.labels.append(.{ .unresolved_goto = ident });
break :blk ident;
};
try names.append(ident);
const elem_ty = try p.arena.create(Type);
elem_ty.* = .{ .specifier = .void };
const result_ty = Type{ .specifier = .pointer, .data = .{ .sub_type = elem_ty } };
const label_addr_node = try p.addNode(.{
.tag = .addr_of_label,
.data = .{ .decl_ref = label },
.ty = result_ty,
.loc = @enumFromInt(ident),
});
try exprs.append(label_addr_node);
num_labels += 1;
if (p.eatToken(.comma) == null) break;
}
} else if (quals.goto) {
try p.errExtra(.expected_token, p.tok_i, .{ .tok_id = .{ .actual = p.tok_ids[p.tok_i], .expected = .colon } });
return error.ParsingFailed;
}
// TODO: validate and insert into AST
return .none;
}
fn checkAsmStr(p: *Parser, asm_str: Value, tok: TokenIndex) !void {
if (!p.comp.langopts.gnu_asm) {
const str = p.comp.interner.get(asm_str.ref()).bytes;
if (str.len > 1) {
// Empty string (just a NUL byte) is ok because it does not emit any assembly
try p.errTok(.gnu_asm_disabled, tok);
}
}
}
/// assembly
/// : keyword_asm asmQual* '(' asmStr ')'
/// | keyword_asm asmQual* '(' gnuAsmStmt ')'
/// | keyword_asm msvcAsmStmt
fn assembly(p: *Parser, kind: enum { global, decl_label, stmt }) Error!?NodeIndex {
const asm_tok = p.tok_i;
switch (p.tok_ids[p.tok_i]) {
.keyword_asm => {
try p.err(.extension_token_used);
p.tok_i += 1;
},
.keyword_asm1, .keyword_asm2 => p.tok_i += 1,
else => return null,
}
if (!p.tok_ids[p.tok_i].canOpenGCCAsmStmt()) {
return p.msvcAsmStmt();
}
var quals: Tree.GNUAssemblyQualifiers = .{};
while (true) : (p.tok_i += 1) switch (p.tok_ids[p.tok_i]) {
.keyword_volatile, .keyword_volatile1, .keyword_volatile2 => {
if (kind != .stmt) try p.errStr(.meaningless_asm_qual, p.tok_i, "volatile");
if (quals.@"volatile") try p.errStr(.duplicate_asm_qual, p.tok_i, "volatile");
quals.@"volatile" = true;
},
.keyword_inline, .keyword_inline1, .keyword_inline2 => {
if (kind != .stmt) try p.errStr(.meaningless_asm_qual, p.tok_i, "inline");
if (quals.@"inline") try p.errStr(.duplicate_asm_qual, p.tok_i, "inline");
quals.@"inline" = true;
},
.keyword_goto => {
if (kind != .stmt) try p.errStr(.meaningless_asm_qual, p.tok_i, "goto");
if (quals.goto) try p.errStr(.duplicate_asm_qual, p.tok_i, "goto");
quals.goto = true;
},
else => break,
};
const l_paren = try p.expectToken(.l_paren);
var result_node: NodeIndex = .none;
switch (kind) {
.decl_label => {
const asm_str = try p.asmStr();
const str = try p.removeNull(asm_str.val);
const attr = Attribute{ .tag = .asm_label, .args = .{ .asm_label = .{ .name = str } }, .syntax = .keyword };
try p.attr_buf.append(p.gpa, .{ .attr = attr, .tok = asm_tok });
},
.global => {
const asm_str = try p.asmStr();
try p.checkAsmStr(asm_str.val, l_paren);
result_node = try p.addNode(.{
.tag = .file_scope_asm,
.ty = .{ .specifier = .void },
.data = .{ .decl = .{ .name = asm_tok, .node = asm_str.node } },
.loc = @enumFromInt(asm_tok),
});
},
.stmt => result_node = try p.gnuAsmStmt(quals, asm_tok, l_paren),
}
try p.expectClosing(l_paren, .r_paren);
if (kind != .decl_label) _ = try p.expectToken(.semicolon);
return result_node;
}
/// Same as stringLiteral but errors on unicode and wide string literals
fn asmStr(p: *Parser) Error!Result {
var i = p.tok_i;
while (true) : (i += 1) switch (p.tok_ids[i]) {
.string_literal, .unterminated_string_literal => {},
.string_literal_utf_16, .string_literal_utf_8, .string_literal_utf_32 => {
try p.errStr(.invalid_asm_str, p.tok_i, "unicode");
return error.ParsingFailed;
},
.string_literal_wide => {
try p.errStr(.invalid_asm_str, p.tok_i, "wide");
return error.ParsingFailed;
},
else => {
if (i == p.tok_i) {
try p.errStr(.expected_str_literal_in, p.tok_i, "asm");
return error.ParsingFailed;
}
break;
},
};
return try p.stringLiteral();
}
// ====== statements ======
/// stmt
/// : labeledStmt
/// | compoundStmt
/// | keyword_if '(' expr ')' stmt (keyword_else stmt)?
/// | keyword_switch '(' expr ')' stmt
/// | keyword_while '(' expr ')' stmt
/// | keyword_do stmt while '(' expr ')' ';'
/// | keyword_for '(' (decl | expr? ';') expr? ';' expr? ')' stmt
/// | keyword_goto (IDENTIFIER | ('*' expr)) ';'
/// | keyword_continue ';'
/// | keyword_break ';'
/// | keyword_return expr? ';'
/// | assembly ';'
/// | expr? ';'
fn stmt(p: *Parser) Error!NodeIndex {
if (try p.labeledStmt()) |some| return some;
if (try p.compoundStmt(false, null)) |some| return some;
if (p.eatToken(.keyword_if)) |kw_if| {
const l_paren = try p.expectToken(.l_paren);
const cond_tok = p.tok_i;
var cond = try p.expr();
try cond.expect(p);
try cond.lvalConversion(p);
try cond.usualUnaryConversion(p, cond_tok);
if (!cond.ty.isScalar())
try p.errStr(.statement_scalar, l_paren + 1, try p.typeStr(cond.ty));
try cond.saveValue(p);
try p.expectClosing(l_paren, .r_paren);
const then = try p.stmt();
const @"else" = if (p.eatToken(.keyword_else)) |_| try p.stmt() else .none;
if (then != .none and @"else" != .none)
return try p.addNode(.{
.tag = .if_then_else_stmt,
.data = .{ .if3 = .{ .cond = cond.node, .body = (try p.addList(&.{ then, @"else" })).start } },
.loc = @enumFromInt(kw_if),
})
else
return try p.addNode(.{
.tag = .if_then_stmt,
.data = .{ .bin = .{ .lhs = cond.node, .rhs = then } },
.loc = @enumFromInt(kw_if),
});
}
if (p.eatToken(.keyword_switch)) |kw_switch| {
const l_paren = try p.expectToken(.l_paren);
const cond_tok = p.tok_i;
var cond = try p.expr();
try cond.expect(p);
try cond.lvalConversion(p);
try cond.usualUnaryConversion(p, cond_tok);
if (!cond.ty.isInt())
try p.errStr(.statement_int, l_paren + 1, try p.typeStr(cond.ty));
try cond.saveValue(p);
try p.expectClosing(l_paren, .r_paren);
const old_switch = p.@"switch";
var @"switch" = Switch{
.ranges = std.ArrayList(Switch.Range).init(p.gpa),
.ty = cond.ty,
.comp = p.comp,
};
p.@"switch" = &@"switch";
defer {
@"switch".ranges.deinit();
p.@"switch" = old_switch;
}
const body = try p.stmt();
return try p.addNode(.{
.tag = .switch_stmt,
.data = .{ .bin = .{ .lhs = cond.node, .rhs = body } },
.loc = @enumFromInt(kw_switch),
});
}
if (p.eatToken(.keyword_while)) |kw_while| {
const l_paren = try p.expectToken(.l_paren);
const cond_tok = p.tok_i;
var cond = try p.expr();
try cond.expect(p);
try cond.lvalConversion(p);
try cond.usualUnaryConversion(p, cond_tok);
if (!cond.ty.isScalar())
try p.errStr(.statement_scalar, l_paren + 1, try p.typeStr(cond.ty));
try cond.saveValue(p);
try p.expectClosing(l_paren, .r_paren);
const body = body: {
const old_loop = p.in_loop;
p.in_loop = true;
defer p.in_loop = old_loop;
break :body try p.stmt();
};
return try p.addNode(.{
.tag = .while_stmt,
.data = .{ .bin = .{ .lhs = cond.node, .rhs = body } },
.loc = @enumFromInt(kw_while),
});
}
if (p.eatToken(.keyword_do)) |kw_do| {
const body = body: {
const old_loop = p.in_loop;
p.in_loop = true;
defer p.in_loop = old_loop;
break :body try p.stmt();
};
_ = try p.expectToken(.keyword_while);
const l_paren = try p.expectToken(.l_paren);
const cond_tok = p.tok_i;
var cond = try p.expr();
try cond.expect(p);
try cond.lvalConversion(p);
try cond.usualUnaryConversion(p, cond_tok);
if (!cond.ty.isScalar())
try p.errStr(.statement_scalar, l_paren + 1, try p.typeStr(cond.ty));
try cond.saveValue(p);
try p.expectClosing(l_paren, .r_paren);
_ = try p.expectToken(.semicolon);
return try p.addNode(.{
.tag = .do_while_stmt,
.data = .{ .bin = .{ .lhs = cond.node, .rhs = body } },
.loc = @enumFromInt(kw_do),
});
}
if (p.eatToken(.keyword_for)) |kw_for| {
try p.syms.pushScope(p);
defer p.syms.popScope();
const decl_buf_top = p.decl_buf.items.len;
defer p.decl_buf.items.len = decl_buf_top;
const l_paren = try p.expectToken(.l_paren);
const got_decl = try p.decl();
// for (init
const init_start = p.tok_i;
var err_start = p.comp.diagnostics.list.items.len;
var init = if (!got_decl) try p.expr() else Result{};
try init.saveValue(p);
try init.maybeWarnUnused(p, init_start, err_start);
if (!got_decl) _ = try p.expectToken(.semicolon);
// for (init; cond
const cond_tok = p.tok_i;
var cond = try p.expr();
if (cond.node != .none) {
try cond.lvalConversion(p);
try cond.usualUnaryConversion(p, cond_tok);
if (!cond.ty.isScalar())
try p.errStr(.statement_scalar, l_paren + 1, try p.typeStr(cond.ty));
}
try cond.saveValue(p);
_ = try p.expectToken(.semicolon);
// for (init; cond; incr
const incr_start = p.tok_i;
err_start = p.comp.diagnostics.list.items.len;
var incr = try p.expr();
try incr.maybeWarnUnused(p, incr_start, err_start);
try incr.saveValue(p);
try p.expectClosing(l_paren, .r_paren);
const body = body: {
const old_loop = p.in_loop;
p.in_loop = true;
defer p.in_loop = old_loop;
break :body try p.stmt();
};
if (got_decl) {
const start = (try p.addList(p.decl_buf.items[decl_buf_top..])).start;
const end = (try p.addList(&.{ cond.node, incr.node, body })).end;
return try p.addNode(.{
.tag = .for_decl_stmt,
.data = .{ .range = .{ .start = start, .end = end } },
.loc = @enumFromInt(kw_for),
});
} else if (init.node == .none and cond.node == .none and incr.node == .none) {
return try p.addNode(.{
.tag = .forever_stmt,
.data = .{ .un = body },
.loc = @enumFromInt(kw_for),
});
} else return try p.addNode(.{
.tag = .for_stmt,
.data = .{ .if3 = .{
.cond = body,
.body = (try p.addList(&.{ init.node, cond.node, incr.node })).start,
} },
.loc = @enumFromInt(kw_for),
});
}
if (p.eatToken(.keyword_goto)) |goto_tok| {
if (p.eatToken(.asterisk)) |_| {
const expr_tok = p.tok_i;
var e = try p.expr();
try e.expect(p);
try e.lvalConversion(p);
p.computed_goto_tok = p.computed_goto_tok orelse goto_tok;
if (!e.ty.isPtr()) {
const elem_ty = try p.arena.create(Type);
elem_ty.* = .{ .specifier = .void, .qual = .{ .@"const" = true } };
const result_ty = Type{
.specifier = .pointer,
.data = .{ .sub_type = elem_ty },
};
if (!e.ty.isInt()) {
try p.errStr(.incompatible_arg, expr_tok, try p.typePairStrExtra(e.ty, " to parameter of incompatible type ", result_ty));
return error.ParsingFailed;
}
if (e.val.isZero(p.comp)) {
try e.nullCast(p, result_ty);
} else {
try p.errStr(.implicit_int_to_ptr, expr_tok, try p.typePairStrExtra(e.ty, " to ", result_ty));
try e.ptrCast(p, result_ty);
}
}
try e.un(p, .computed_goto_stmt, goto_tok);
_ = try p.expectToken(.semicolon);
return e.node;
}
const name_tok = try p.expectIdentifier();
const str = p.tokSlice(name_tok);
if (p.findLabel(str) == null) {
try p.labels.append(.{ .unresolved_goto = name_tok });
}
_ = try p.expectToken(.semicolon);
return try p.addNode(.{
.tag = .goto_stmt,
.data = .{ .decl_ref = name_tok },
.loc = @enumFromInt(goto_tok),
});
}
if (p.eatToken(.keyword_continue)) |cont| {
if (!p.in_loop) try p.errTok(.continue_not_in_loop, cont);
_ = try p.expectToken(.semicolon);
return try p.addNode(.{ .tag = .continue_stmt, .data = undefined, .loc = @enumFromInt(cont) });
}
if (p.eatToken(.keyword_break)) |br| {
if (!p.in_loop and p.@"switch" == null) try p.errTok(.break_not_in_loop_or_switch, br);
_ = try p.expectToken(.semicolon);
return try p.addNode(.{ .tag = .break_stmt, .data = undefined, .loc = @enumFromInt(br) });
}
if (try p.returnStmt()) |some| return some;
if (try p.assembly(.stmt)) |some| return some;
const expr_start = p.tok_i;
const err_start = p.comp.diagnostics.list.items.len;
const e = try p.expr();
if (e.node != .none) {
_ = try p.expectToken(.semicolon);
try e.maybeWarnUnused(p, expr_start, err_start);
return e.node;
}
const attr_buf_top = p.attr_buf.len;
defer p.attr_buf.len = attr_buf_top;
try p.attributeSpecifier();
if (p.eatToken(.semicolon)) |semicolon| {
var null_node: Tree.Node = .{ .tag = .null_stmt, .data = undefined, .loc = @enumFromInt(semicolon) };
null_node.ty = try Attribute.applyStatementAttributes(p, null_node.ty, expr_start, attr_buf_top);
return p.addNode(null_node);
}
try p.err(.expected_stmt);
return error.ParsingFailed;
}
/// labeledStmt
/// : IDENTIFIER ':' stmt
/// | keyword_case integerConstExpr ':' stmt
/// | keyword_default ':' stmt
fn labeledStmt(p: *Parser) Error!?NodeIndex {
if ((p.tok_ids[p.tok_i] == .identifier or p.tok_ids[p.tok_i] == .extended_identifier) and p.tok_ids[p.tok_i + 1] == .colon) {
const name_tok = try p.expectIdentifier();
const str = p.tokSlice(name_tok);
if (p.findLabel(str)) |some| {
try p.errStr(.duplicate_label, name_tok, str);
try p.errStr(.previous_label, some, str);
} else {
p.label_count += 1;
try p.labels.append(.{ .label = name_tok });
var i: usize = 0;
while (i < p.labels.items.len) {
if (p.labels.items[i] == .unresolved_goto and
mem.eql(u8, p.tokSlice(p.labels.items[i].unresolved_goto), str))
{
_ = p.labels.swapRemove(i);
} else i += 1;
}
}
p.tok_i += 1;
const attr_buf_top = p.attr_buf.len;
defer p.attr_buf.len = attr_buf_top;
try p.attributeSpecifier();
var labeled_stmt = Tree.Node{
.tag = .labeled_stmt,
.data = .{ .decl = .{ .name = name_tok, .node = try p.labelableStmt() } },
.loc = @enumFromInt(name_tok),
};
labeled_stmt.ty = try Attribute.applyLabelAttributes(p, labeled_stmt.ty, attr_buf_top);
return try p.addNode(labeled_stmt);
} else if (p.eatToken(.keyword_case)) |case| {
const first_item = try p.integerConstExpr(.gnu_folding_extension);
const ellipsis = p.tok_i;
const second_item = if (p.eatToken(.ellipsis) != null) blk: {
try p.errTok(.gnu_switch_range, ellipsis);
break :blk try p.integerConstExpr(.gnu_folding_extension);
} else null;
_ = try p.expectToken(.colon);
if (p.@"switch") |some| check: {
if (some.ty.hasIncompleteSize()) break :check; // error already reported for incomplete size
const first = first_item.val;
const last = if (second_item) |second| second.val else first;
if (first.opt_ref == .none) {
try p.errTok(.case_val_unavailable, case + 1);
break :check;
} else if (last.opt_ref == .none) {
try p.errTok(.case_val_unavailable, ellipsis + 1);
break :check;
} else if (last.compare(.lt, first, p.comp)) {
try p.errTok(.empty_case_range, case + 1);
break :check;
}
// TODO cast to target type
const prev = (try some.add(first, last, case + 1)) orelse break :check;
// TODO check which value was already handled
try p.errStr(.duplicate_switch_case, case + 1, try first_item.str(p));
try p.errTok(.previous_case, prev.tok);
} else {
try p.errStr(.case_not_in_switch, case, "case");
}
const s = try p.labelableStmt();
if (second_item) |some| return try p.addNode(.{
.tag = .case_range_stmt,
.data = .{ .if3 = .{ .cond = s, .body = (try p.addList(&.{ first_item.node, some.node })).start } },
.loc = @enumFromInt(case),
}) else return try p.addNode(.{
.tag = .case_stmt,
.data = .{ .bin = .{ .lhs = first_item.node, .rhs = s } },
.loc = @enumFromInt(case),
});
} else if (p.eatToken(.keyword_default)) |default| {
_ = try p.expectToken(.colon);
const s = try p.labelableStmt();
const node = try p.addNode(.{
.tag = .default_stmt,
.data = .{ .un = s },
.loc = @enumFromInt(default),
});
const @"switch" = p.@"switch" orelse {
try p.errStr(.case_not_in_switch, default, "default");
return node;
};
if (@"switch".default) |previous| {
try p.errTok(.multiple_default, default);
try p.errTok(.previous_case, previous);
} else {
@"switch".default = default;
}
return node;
} else return null;
}
fn labelableStmt(p: *Parser) Error!NodeIndex {
if (p.tok_ids[p.tok_i] == .r_brace) {
try p.err(.label_compound_end);
return p.addNode(.{ .tag = .null_stmt, .data = undefined, .loc = @enumFromInt(p.tok_i) });
}
return p.stmt();
}
const StmtExprState = struct {
last_expr_tok: TokenIndex = 0,
last_expr_res: Result = .{ .ty = .{ .specifier = .void } },
};
/// compoundStmt : '{' ( decl | keyword_extension decl | staticAssert | stmt)* '}'
fn compoundStmt(p: *Parser, is_fn_body: bool, stmt_expr_state: ?*StmtExprState) Error!?NodeIndex {
const l_brace = p.eatToken(.l_brace) orelse return null;
const decl_buf_top = p.decl_buf.items.len;
defer p.decl_buf.items.len = decl_buf_top;
// the parameters of a function are in the same scope as the body
if (!is_fn_body) try p.syms.pushScope(p);
defer if (!is_fn_body) p.syms.popScope();
var noreturn_index: ?TokenIndex = null;
var noreturn_label_count: u32 = 0;
while (p.eatToken(.r_brace) == null) : (_ = try p.pragma()) {
if (stmt_expr_state) |state| state.* = .{};
if (try p.parseOrNextStmt(staticAssert, l_brace)) continue;
if (try p.parseOrNextStmt(decl, l_brace)) continue;
if (p.eatToken(.keyword_extension)) |ext| {
const saved_extension = p.extension_suppressed;
defer p.extension_suppressed = saved_extension;
p.extension_suppressed = true;
if (try p.parseOrNextStmt(decl, l_brace)) continue;
p.tok_i = ext;
}
const stmt_tok = p.tok_i;
const s = p.stmt() catch |er| switch (er) {
error.ParsingFailed => {
try p.nextStmt(l_brace);
continue;
},
else => |e| return e,
};
if (s == .none) continue;
if (stmt_expr_state) |state| {
state.* = .{
.last_expr_tok = stmt_tok,
.last_expr_res = .{
.node = s,
.ty = p.nodes.items(.ty)[@intFromEnum(s)],
},
};
}
try p.decl_buf.append(s);
if (noreturn_index == null and p.nodeIsNoreturn(s) == .yes) {
noreturn_index = p.tok_i;
noreturn_label_count = p.label_count;
}
switch (p.nodes.items(.tag)[@intFromEnum(s)]) {
.case_stmt, .default_stmt, .labeled_stmt => noreturn_index = null,
else => {},
}
}
const r_brace = p.tok_i - 1;
if (noreturn_index) |some| {
// if new labels were defined we cannot be certain that the code is unreachable
if (some != p.tok_i - 1 and noreturn_label_count == p.label_count) try p.errTok(.unreachable_code, some);
}
if (is_fn_body) {
const last_noreturn = if (p.decl_buf.items.len == decl_buf_top)
.no
else
p.nodeIsNoreturn(p.decl_buf.items[p.decl_buf.items.len - 1]);
if (last_noreturn != .yes) {
const ret_ty = p.func.ty.?.returnType();
var return_zero = false;
if (last_noreturn == .no and !ret_ty.is(.void) and !ret_ty.isFunc() and !ret_ty.isArray()) {
const func_name = p.tokSlice(p.func.name);
const interned_name = try StrInt.intern(p.comp, func_name);
if (interned_name == p.string_ids.main_id and ret_ty.is(.int)) {
return_zero = true;
} else {
try p.errStr(.func_does_not_return, p.tok_i - 1, func_name);
}
}
try p.decl_buf.append(try p.addNode(.{ .tag = .implicit_return, .ty = p.func.ty.?.returnType(), .data = .{ .return_zero = return_zero }, .loc = @enumFromInt(r_brace) }));
}
if (p.func.ident) |some| try p.decl_buf.insert(decl_buf_top, some.node);
if (p.func.pretty_ident) |some| try p.decl_buf.insert(decl_buf_top, some.node);
}
var node: Tree.Node = .{
.tag = .compound_stmt_two,
.data = .{ .two = .{ .none, .none } },
.loc = @enumFromInt(l_brace),
};
const statements = p.decl_buf.items[decl_buf_top..];
switch (statements.len) {
0 => {},
1 => node.data = .{ .two = .{ statements[0], .none } },
2 => node.data = .{ .two = .{ statements[0], statements[1] } },
else => {
node.tag = .compound_stmt;
node.data = .{ .range = try p.addList(statements) };
},
}
return try p.addNode(node);
}
const NoreturnKind = enum { no, yes, complex };
fn nodeIsNoreturn(p: *Parser, node: NodeIndex) NoreturnKind {
switch (p.nodes.items(.tag)[@intFromEnum(node)]) {
.break_stmt, .continue_stmt, .return_stmt => return .yes,
.if_then_else_stmt => {
const data = p.data.items[p.nodes.items(.data)[@intFromEnum(node)].if3.body..];
const then_type = p.nodeIsNoreturn(data[0]);
const else_type = p.nodeIsNoreturn(data[1]);
if (then_type == .complex or else_type == .complex) return .complex;
if (then_type == .yes and else_type == .yes) return .yes;
return .no;
},
.compound_stmt_two => {
const data = p.nodes.items(.data)[@intFromEnum(node)];
const lhs_type = if (data.two[0] != .none) p.nodeIsNoreturn(data.two[0]) else .no;
const rhs_type = if (data.two[1] != .none) p.nodeIsNoreturn(data.two[1]) else .no;
if (lhs_type == .complex or rhs_type == .complex) return .complex;
if (lhs_type == .yes or rhs_type == .yes) return .yes;
return .no;
},
.compound_stmt => {
const data = p.nodes.items(.data)[@intFromEnum(node)];
var it = data.range.start;
while (it != data.range.end) : (it += 1) {
const kind = p.nodeIsNoreturn(p.data.items[it]);
if (kind != .no) return kind;
}
return .no;
},
.labeled_stmt => {
const data = p.nodes.items(.data)[@intFromEnum(node)];
return p.nodeIsNoreturn(data.decl.node);
},
.default_stmt => {
const data = p.nodes.items(.data)[@intFromEnum(node)];
if (data.un == .none) return .no;
return p.nodeIsNoreturn(data.un);
},
.while_stmt, .do_while_stmt, .for_decl_stmt, .forever_stmt, .for_stmt, .switch_stmt => return .complex,
else => return .no,
}
}
fn parseOrNextStmt(p: *Parser, comptime func: fn (*Parser) Error!bool, l_brace: TokenIndex) !bool {
return func(p) catch |er| switch (er) {
error.ParsingFailed => {
try p.nextStmt(l_brace);
return true;
},
else => |e| return e,
};
}
fn nextStmt(p: *Parser, l_brace: TokenIndex) !void {
var parens: u32 = 0;
while (p.tok_i < p.tok_ids.len) : (p.tok_i += 1) {
switch (p.tok_ids[p.tok_i]) {
.l_paren, .l_brace, .l_bracket => parens += 1,
.r_paren, .r_bracket => if (parens != 0) {
parens -= 1;
},
.r_brace => if (parens == 0)
return
else {
parens -= 1;
},
.semicolon => if (parens == 0) {
p.tok_i += 1;
return;
},
.keyword_for,
.keyword_while,
.keyword_do,
.keyword_if,
.keyword_goto,
.keyword_switch,
.keyword_case,
.keyword_default,
.keyword_continue,
.keyword_break,
.keyword_return,
.keyword_typedef,
.keyword_extern,
.keyword_static,
.keyword_auto,
.keyword_register,
.keyword_thread_local,
.keyword_c23_thread_local,
.keyword_inline,
.keyword_inline1,
.keyword_inline2,
.keyword_noreturn,
.keyword_void,
.keyword_bool,
.keyword_c23_bool,
.keyword_char,
.keyword_short,
.keyword_int,
.keyword_long,
.keyword_signed,
.keyword_signed1,
.keyword_signed2,
.keyword_unsigned,
.keyword_float,
.keyword_double,
.keyword_complex,
.keyword_atomic,
.keyword_enum,
.keyword_struct,
.keyword_union,
.keyword_alignas,
.keyword_c23_alignas,
.keyword_typeof,
.keyword_typeof1,
.keyword_typeof2,
.keyword_typeof_unqual,
.keyword_extension,
=> if (parens == 0) return,
.keyword_pragma => p.skipToPragmaSentinel(),
else => {},
}
}
p.tok_i -= 1; // So we can consume EOF
try p.expectClosing(l_brace, .r_brace);
unreachable;
}
fn returnStmt(p: *Parser) Error!?NodeIndex {
const ret_tok = p.eatToken(.keyword_return) orelse return null;
const e_tok = p.tok_i;
var e = try p.expr();
_ = try p.expectToken(.semicolon);
const ret_ty = p.func.ty.?.returnType();
if (p.func.ty.?.hasAttribute(.noreturn)) {
try p.errStr(.invalid_noreturn, e_tok, p.tokSlice(p.func.name));
}
if (e.node == .none) {
if (!ret_ty.is(.void)) try p.errStr(.func_should_return, ret_tok, p.tokSlice(p.func.name));
return try p.addNode(.{ .tag = .return_stmt, .data = .{ .un = e.node }, .loc = @enumFromInt(ret_tok) });
} else if (ret_ty.is(.void)) {
try p.errStr(.void_func_returns_value, e_tok, p.tokSlice(p.func.name));
return try p.addNode(.{ .tag = .return_stmt, .data = .{ .un = e.node }, .loc = @enumFromInt(ret_tok) });
}
try e.lvalConversion(p);
try e.coerce(p, ret_ty, e_tok, .ret);
try e.saveValue(p);
return try p.addNode(.{ .tag = .return_stmt, .data = .{ .un = e.node }, .loc = @enumFromInt(ret_tok) });
}
// ====== expressions ======
pub fn macroExpr(p: *Parser) Compilation.Error!bool {
const res = p.condExpr() catch |e| switch (e) {
error.OutOfMemory => return error.OutOfMemory,
error.FatalError => return error.FatalError,
error.ParsingFailed => return false,
};
if (res.val.opt_ref == .none) {
try p.errTok(.expected_expr, p.tok_i);
return false;
}
return res.val.toBool(p.comp);
}
const CallExpr = union(enum) {
standard: NodeIndex,
builtin: struct {
node: NodeIndex,
tag: Builtin.Tag,
},
fn init(p: *Parser, call_node: NodeIndex, func_node: NodeIndex) CallExpr {
if (p.getNode(call_node, .builtin_call_expr_one)) |node| {
const data = p.nodes.items(.data)[@intFromEnum(node)];
const name = p.tokSlice(data.decl.name);
const builtin_ty = p.comp.builtins.lookup(name);
return .{ .builtin = .{ .node = node, .tag = builtin_ty.builtin.tag } };
}
return .{ .standard = func_node };
}
fn shouldPerformLvalConversion(self: CallExpr, arg_idx: u32) bool {
return switch (self) {
.standard => true,
.builtin => |builtin| switch (builtin.tag) {
Builtin.tagFromName("__builtin_va_start").?,
Builtin.tagFromName("__va_start").?,
Builtin.tagFromName("va_start").?,
=> arg_idx != 1,
else => true,
},
};
}
fn shouldPromoteVarArg(self: CallExpr, arg_idx: u32) bool {
return switch (self) {
.standard => true,
.builtin => |builtin| switch (builtin.tag) {
Builtin.tagFromName("__builtin_va_start").?,
Builtin.tagFromName("__va_start").?,
Builtin.tagFromName("va_start").?,
=> arg_idx != 1,
Builtin.tagFromName("__builtin_add_overflow").?,
Builtin.tagFromName("__builtin_complex").?,
Builtin.tagFromName("__builtin_isinf").?,
Builtin.tagFromName("__builtin_isinf_sign").?,
Builtin.tagFromName("__builtin_mul_overflow").?,
Builtin.tagFromName("__builtin_isnan").?,
Builtin.tagFromName("__builtin_sub_overflow").?,
=> false,
else => true,
},
};
}
fn shouldCoerceArg(self: CallExpr, arg_idx: u32) bool {
_ = self;
_ = arg_idx;
return true;
}
fn checkVarArg(self: CallExpr, p: *Parser, first_after: TokenIndex, param_tok: TokenIndex, arg: *Result, arg_idx: u32) !void {
if (self == .standard) return;
const builtin_tok = p.nodes.items(.data)[@intFromEnum(self.builtin.node)].decl.name;
switch (self.builtin.tag) {
Builtin.tagFromName("__builtin_va_start").?,
Builtin.tagFromName("__va_start").?,
Builtin.tagFromName("va_start").?,
=> return p.checkVaStartArg(builtin_tok, first_after, param_tok, arg, arg_idx),
Builtin.tagFromName("__builtin_complex").? => return p.checkComplexArg(builtin_tok, first_after, param_tok, arg, arg_idx),
Builtin.tagFromName("__builtin_add_overflow").?,
Builtin.tagFromName("__builtin_sub_overflow").?,
Builtin.tagFromName("__builtin_mul_overflow").?,
=> return p.checkArithOverflowArg(builtin_tok, first_after, param_tok, arg, arg_idx),
else => {},
}
}
/// Some functions cannot be expressed as standard C prototypes. For example `__builtin_complex` requires
/// two arguments of the same real floating point type (e.g. two doubles or two floats). These functions are
/// encoded as varargs functions with custom typechecking. Since varargs functions do not have a fixed number
/// of arguments, `paramCountOverride` is used to tell us how many arguments we should actually expect to see for
/// these custom-typechecked functions.
fn paramCountOverride(self: CallExpr) ?u32 {
return switch (self) {
.standard => null,
.builtin => |builtin| switch (builtin.tag) {
Builtin.tagFromName("__c11_atomic_thread_fence").?,
Builtin.tagFromName("__c11_atomic_signal_fence").?,
Builtin.tagFromName("__c11_atomic_is_lock_free").?,
Builtin.tagFromName("__builtin_isinf").?,
Builtin.tagFromName("__builtin_isinf_sign").?,
Builtin.tagFromName("__builtin_isnan").?,
=> 1,
Builtin.tagFromName("__builtin_complex").?,
Builtin.tagFromName("__c11_atomic_load").?,
Builtin.tagFromName("__c11_atomic_init").?,
=> 2,
Builtin.tagFromName("__c11_atomic_store").?,
Builtin.tagFromName("__c11_atomic_exchange").?,
Builtin.tagFromName("__c11_atomic_fetch_add").?,
Builtin.tagFromName("__c11_atomic_fetch_sub").?,
Builtin.tagFromName("__c11_atomic_fetch_or").?,
Builtin.tagFromName("__c11_atomic_fetch_xor").?,
Builtin.tagFromName("__c11_atomic_fetch_and").?,
Builtin.tagFromName("__atomic_fetch_add").?,
Builtin.tagFromName("__atomic_fetch_sub").?,
Builtin.tagFromName("__atomic_fetch_and").?,
Builtin.tagFromName("__atomic_fetch_xor").?,
Builtin.tagFromName("__atomic_fetch_or").?,
Builtin.tagFromName("__atomic_fetch_nand").?,
Builtin.tagFromName("__atomic_add_fetch").?,
Builtin.tagFromName("__atomic_sub_fetch").?,
Builtin.tagFromName("__atomic_and_fetch").?,
Builtin.tagFromName("__atomic_xor_fetch").?,
Builtin.tagFromName("__atomic_or_fetch").?,
Builtin.tagFromName("__atomic_nand_fetch").?,
Builtin.tagFromName("__builtin_add_overflow").?,
Builtin.tagFromName("__builtin_sub_overflow").?,
Builtin.tagFromName("__builtin_mul_overflow").?,
=> 3,
Builtin.tagFromName("__c11_atomic_compare_exchange_strong").?,
Builtin.tagFromName("__c11_atomic_compare_exchange_weak").?,
=> 5,
Builtin.tagFromName("__atomic_compare_exchange").?,
Builtin.tagFromName("__atomic_compare_exchange_n").?,
=> 6,
else => null,
},
};
}
fn returnType(self: CallExpr, p: *Parser, callable_ty: Type) Type {
return switch (self) {
.standard => callable_ty.returnType(),
.builtin => |builtin| switch (builtin.tag) {
Builtin.tagFromName("__c11_atomic_exchange").? => {
if (p.list_buf.items.len != 4) return Type.invalid; // wrong number of arguments; already an error
const second_param = p.list_buf.items[2];
return p.nodes.items(.ty)[@intFromEnum(second_param)];
},
Builtin.tagFromName("__c11_atomic_load").? => {
if (p.list_buf.items.len != 3) return Type.invalid; // wrong number of arguments; already an error
const first_param = p.list_buf.items[1];
const ty = p.nodes.items(.ty)[@intFromEnum(first_param)];
if (!ty.isPtr()) return Type.invalid;
return ty.elemType();
},
Builtin.tagFromName("__atomic_fetch_add").?,
Builtin.tagFromName("__atomic_add_fetch").?,
Builtin.tagFromName("__c11_atomic_fetch_add").?,
Builtin.tagFromName("__atomic_fetch_sub").?,
Builtin.tagFromName("__atomic_sub_fetch").?,
Builtin.tagFromName("__c11_atomic_fetch_sub").?,
Builtin.tagFromName("__atomic_fetch_and").?,
Builtin.tagFromName("__atomic_and_fetch").?,
Builtin.tagFromName("__c11_atomic_fetch_and").?,
Builtin.tagFromName("__atomic_fetch_xor").?,
Builtin.tagFromName("__atomic_xor_fetch").?,
Builtin.tagFromName("__c11_atomic_fetch_xor").?,
Builtin.tagFromName("__atomic_fetch_or").?,
Builtin.tagFromName("__atomic_or_fetch").?,
Builtin.tagFromName("__c11_atomic_fetch_or").?,
Builtin.tagFromName("__atomic_fetch_nand").?,
Builtin.tagFromName("__atomic_nand_fetch").?,
Builtin.tagFromName("__c11_atomic_fetch_nand").?,
=> {
if (p.list_buf.items.len != 3) return Type.invalid; // wrong number of arguments; already an error
const second_param = p.list_buf.items[2];
return p.nodes.items(.ty)[@intFromEnum(second_param)];
},
Builtin.tagFromName("__builtin_complex").? => {
if (p.list_buf.items.len < 1) return Type.invalid; // not enough arguments; already an error
const last_param = p.list_buf.items[p.list_buf.items.len - 1];
return p.nodes.items(.ty)[@intFromEnum(last_param)].makeComplex();
},
Builtin.tagFromName("__atomic_compare_exchange").?,
Builtin.tagFromName("__atomic_compare_exchange_n").?,
Builtin.tagFromName("__c11_atomic_is_lock_free").?,
=> .{ .specifier = .bool },
else => callable_ty.returnType(),
Builtin.tagFromName("__c11_atomic_compare_exchange_strong").?,
Builtin.tagFromName("__c11_atomic_compare_exchange_weak").?,
=> {
if (p.list_buf.items.len != 6) return Type.invalid; // wrong number of arguments
const third_param = p.list_buf.items[3];
return p.nodes.items(.ty)[@intFromEnum(third_param)];
},
},
};
}
fn finish(self: CallExpr, p: *Parser, ty: Type, list_buf_top: usize, arg_count: u32) Error!Result {
const ret_ty = self.returnType(p, ty);
switch (self) {
.standard => |func_node| {
var call_node: Tree.Node = .{
.tag = .call_expr_one,
.ty = ret_ty,
.data = .{ .two = .{ func_node, .none } },
};
const args = p.list_buf.items[list_buf_top..];
switch (arg_count) {
0 => {},
1 => call_node.data.two[1] = args[1], // args[0] == func.node
else => {
call_node.tag = .call_expr;
call_node.data = .{ .range = try p.addList(args) };
},
}
return Result{ .node = try p.addNode(call_node), .ty = ret_ty };
},
.builtin => |builtin| {
const index = @intFromEnum(builtin.node);
var call_node = p.nodes.get(index);
defer p.nodes.set(index, call_node);
call_node.ty = ret_ty;
const args = p.list_buf.items[list_buf_top..];
switch (arg_count) {
0 => {},
1 => call_node.data.decl.node = args[1], // args[0] == func.node
else => {
call_node.tag = .builtin_call_expr;
args[0] = @enumFromInt(call_node.data.decl.name);
call_node.data = .{ .range = try p.addList(args) };
},
}
const val = try evalBuiltin(builtin.tag, p, args[1..]);
return Result{ .node = builtin.node, .ty = ret_ty, .val = val };
},
}
}
};
pub const Result = struct {
node: NodeIndex = .none,
ty: Type = .{ .specifier = .int },
val: Value = .{},
const invalid: Result = .{ .ty = Type.invalid };
pub fn str(res: Result, p: *Parser) ![]const u8 {
switch (res.val.opt_ref) {
.none => return "(none)",
.null => return "nullptr_t",
else => {},
}
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
try res.val.print(res.ty, p.comp, p.strings.writer());
return try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
}
fn expect(res: Result, p: *Parser) Error!void {
if (p.in_macro) {
if (res.val.opt_ref == .none) {
try p.errTok(.expected_expr, p.tok_i);
return error.ParsingFailed;
}
return;
}
if (res.node == .none) {
try p.errTok(.expected_expr, p.tok_i);
return error.ParsingFailed;
}
}
fn empty(res: Result, p: *Parser) bool {
if (p.in_macro) return res.val.opt_ref == .none;
return res.node == .none;
}
fn maybeWarnUnused(res: Result, p: *Parser, expr_start: TokenIndex, err_start: usize) Error!void {
if (res.ty.is(.void) or res.node == .none) return;
// don't warn about unused result if the expression contained errors besides other unused results
for (p.comp.diagnostics.list.items[err_start..]) |err_item| {
if (err_item.tag != .unused_value) return;
}
var cur_node = res.node;
while (true) switch (p.nodes.items(.tag)[@intFromEnum(cur_node)]) {
.invalid, // So that we don't need to check for node == 0
.assign_expr,
.mul_assign_expr,
.div_assign_expr,
.mod_assign_expr,
.add_assign_expr,
.sub_assign_expr,
.shl_assign_expr,
.shr_assign_expr,
.bit_and_assign_expr,
.bit_xor_assign_expr,
.bit_or_assign_expr,
.pre_inc_expr,
.pre_dec_expr,
.post_inc_expr,
.post_dec_expr,
=> return,
.call_expr, .call_expr_one => {
const tmp_tree = p.tmpTree();
const child_nodes = tmp_tree.childNodes(cur_node);
const fn_ptr = child_nodes[0];
const call_info = tmp_tree.callableResultUsage(fn_ptr) orelse return;
if (call_info.nodiscard) try p.errStr(.nodiscard_unused, expr_start, p.tokSlice(call_info.tok));
if (call_info.warn_unused_result) try p.errStr(.warn_unused_result, expr_start, p.tokSlice(call_info.tok));
return;
},
.stmt_expr => {
const body = p.nodes.items(.data)[@intFromEnum(cur_node)].un;
switch (p.nodes.items(.tag)[@intFromEnum(body)]) {
.compound_stmt_two => {
const body_stmt = p.nodes.items(.data)[@intFromEnum(body)].two;
cur_node = if (body_stmt[1] != .none) body_stmt[1] else body_stmt[0];
},
.compound_stmt => {
const data = p.nodes.items(.data)[@intFromEnum(body)];
cur_node = p.data.items[data.range.end - 1];
},
else => unreachable,
}
},
.comma_expr => cur_node = p.nodes.items(.data)[@intFromEnum(cur_node)].bin.rhs,
.paren_expr => cur_node = p.nodes.items(.data)[@intFromEnum(cur_node)].un,
else => break,
};
try p.errTok(.unused_value, expr_start);
}
fn boolRes(lhs: *Result, p: *Parser, tag: Tree.Tag, rhs: Result, tok_i: TokenIndex) !void {
if (lhs.val.opt_ref == .null) {
lhs.val = Value.zero;
}
if (lhs.ty.specifier != .invalid) {
lhs.ty = Type.int;
}
return lhs.bin(p, tag, rhs, tok_i);
}
fn bin(lhs: *Result, p: *Parser, tag: Tree.Tag, rhs: Result, tok_i: TokenIndex) !void {
lhs.node = try p.addNode(.{
.tag = tag,
.ty = lhs.ty,
.data = .{ .bin = .{ .lhs = lhs.node, .rhs = rhs.node } },
.loc = @enumFromInt(tok_i),
});
}
fn un(operand: *Result, p: *Parser, tag: Tree.Tag, tok_i: TokenIndex) Error!void {
operand.node = try p.addNode(.{
.tag = tag,
.ty = operand.ty,
.data = .{ .un = operand.node },
.loc = @enumFromInt(tok_i),
});
}
fn implicitCast(operand: *Result, p: *Parser, kind: Tree.CastKind) Error!void {
operand.node = try p.addNode(.{
.tag = .implicit_cast,
.ty = operand.ty,
.data = .{ .cast = .{ .operand = operand.node, .kind = kind } },
});
}
fn adjustCondExprPtrs(a: *Result, tok: TokenIndex, b: *Result, p: *Parser) !bool {
assert(a.ty.isPtr() and b.ty.isPtr());
const a_elem = a.ty.elemType();
const b_elem = b.ty.elemType();
if (a_elem.eql(b_elem, p.comp, true)) return true;
var adjusted_elem_ty = try p.arena.create(Type);
adjusted_elem_ty.* = a_elem;
const has_void_star_branch = a.ty.isVoidStar() or b.ty.isVoidStar();
const only_quals_differ = a_elem.eql(b_elem, p.comp, false);
const pointers_compatible = only_quals_differ or has_void_star_branch;
if (!pointers_compatible or has_void_star_branch) {
if (!pointers_compatible) {
try p.errStr(.pointer_mismatch, tok, try p.typePairStrExtra(a.ty, " and ", b.ty));
}
adjusted_elem_ty.* = .{ .specifier = .void };
}
if (pointers_compatible) {
adjusted_elem_ty.qual = a_elem.qual.mergeCV(b_elem.qual);
}
if (!adjusted_elem_ty.eql(a_elem, p.comp, true)) {
a.ty = .{
.data = .{ .sub_type = adjusted_elem_ty },
.specifier = .pointer,
};
try a.implicitCast(p, .bitcast);
}
if (!adjusted_elem_ty.eql(b_elem, p.comp, true)) {
b.ty = .{
.data = .{ .sub_type = adjusted_elem_ty },
.specifier = .pointer,
};
try b.implicitCast(p, .bitcast);
}
return true;
}
/// Adjust types for binary operation, returns true if the result can and should be evaluated.
fn adjustTypes(a: *Result, tok: TokenIndex, b: *Result, p: *Parser, kind: enum {
integer,
arithmetic,
boolean_logic,
relational,
equality,
conditional,
add,
sub,
}) !bool {
if (b.ty.specifier == .invalid) {
try a.saveValue(p);
a.ty = Type.invalid;
}
if (a.ty.specifier == .invalid) {
return false;
}
try a.lvalConversion(p);
try b.lvalConversion(p);
const a_vec = a.ty.is(.vector);
const b_vec = b.ty.is(.vector);
if (a_vec and b_vec) {
if (a.ty.eql(b.ty, p.comp, false)) {
return a.shouldEval(b, p);
}
return a.invalidBinTy(tok, b, p);
} else if (a_vec) {
if (b.coerceExtra(p, a.ty.elemType(), tok, .test_coerce)) {
try b.saveValue(p);
try b.implicitCast(p, .vector_splat);
return a.shouldEval(b, p);
} else |er| switch (er) {
error.CoercionFailed => return a.invalidBinTy(tok, b, p),
else => |e| return e,
}
} else if (b_vec) {
if (a.coerceExtra(p, b.ty.elemType(), tok, .test_coerce)) {
try a.saveValue(p);
try a.implicitCast(p, .vector_splat);
return a.shouldEval(b, p);
} else |er| switch (er) {
error.CoercionFailed => return a.invalidBinTy(tok, b, p),
else => |e| return e,
}
}
const a_int = a.ty.isInt();
const b_int = b.ty.isInt();
if (a_int and b_int) {
try a.usualArithmeticConversion(b, p, tok);
return a.shouldEval(b, p);
}
if (kind == .integer) return a.invalidBinTy(tok, b, p);
const a_float = a.ty.isFloat();
const b_float = b.ty.isFloat();
const a_arithmetic = a_int or a_float;
const b_arithmetic = b_int or b_float;
if (a_arithmetic and b_arithmetic) {
// <, <=, >, >= only work on real types
if (kind == .relational and (!a.ty.isReal() or !b.ty.isReal()))
return a.invalidBinTy(tok, b, p);
try a.usualArithmeticConversion(b, p, tok);
return a.shouldEval(b, p);
}
if (kind == .arithmetic) return a.invalidBinTy(tok, b, p);
const a_nullptr = a.ty.is(.nullptr_t);
const b_nullptr = b.ty.is(.nullptr_t);
const a_ptr = a.ty.isPtr();
const b_ptr = b.ty.isPtr();
const a_scalar = a_arithmetic or a_ptr;
const b_scalar = b_arithmetic or b_ptr;
switch (kind) {
.boolean_logic => {
if (!(a_scalar or a_nullptr) or !(b_scalar or b_nullptr)) return a.invalidBinTy(tok, b, p);
// Do integer promotions but nothing else
if (a_int) try a.intCast(p, a.ty.integerPromotion(p.comp), tok);
if (b_int) try b.intCast(p, b.ty.integerPromotion(p.comp), tok);
return a.shouldEval(b, p);
},
.relational, .equality => {
if (kind == .equality and (a_nullptr or b_nullptr)) {
if (a_nullptr and b_nullptr) return a.shouldEval(b, p);
const nullptr_res = if (a_nullptr) a else b;
const other_res = if (a_nullptr) b else a;
if (other_res.ty.isPtr()) {
try nullptr_res.nullCast(p, other_res.ty);
return other_res.shouldEval(nullptr_res, p);
} else if (other_res.val.isZero(p.comp)) {
other_res.val = Value.null;
try other_res.nullCast(p, nullptr_res.ty);
return other_res.shouldEval(nullptr_res, p);
}
return a.invalidBinTy(tok, b, p);
}
// comparisons between floats and pointes not allowed
if (!a_scalar or !b_scalar or (a_float and b_ptr) or (b_float and a_ptr))
return a.invalidBinTy(tok, b, p);
if ((a_int or b_int) and !(a.val.isZero(p.comp) or b.val.isZero(p.comp))) {
try p.errStr(.comparison_ptr_int, tok, try p.typePairStr(a.ty, b.ty));
} else if (a_ptr and b_ptr) {
if (!a.ty.isVoidStar() and !b.ty.isVoidStar() and !a.ty.eql(b.ty, p.comp, false))
try p.errStr(.comparison_distinct_ptr, tok, try p.typePairStr(a.ty, b.ty));
} else if (a_ptr) {
try b.ptrCast(p, a.ty);
} else {
assert(b_ptr);
try a.ptrCast(p, b.ty);
}
return a.shouldEval(b, p);
},
.conditional => {
// doesn't matter what we return here, as the result is ignored
if (a.ty.is(.void) or b.ty.is(.void)) {
try a.toVoid(p);
try b.toVoid(p);
return true;
}
if (a_nullptr and b_nullptr) return true;
if ((a_ptr and b_int) or (a_int and b_ptr)) {
if (a.val.isZero(p.comp) or b.val.isZero(p.comp)) {
try a.nullCast(p, b.ty);
try b.nullCast(p, a.ty);
return true;
}
const int_ty = if (a_int) a else b;
const ptr_ty = if (a_ptr) a else b;
try p.errStr(.implicit_int_to_ptr, tok, try p.typePairStrExtra(int_ty.ty, " to ", ptr_ty.ty));
try int_ty.ptrCast(p, ptr_ty.ty);
return true;
}
if (a_ptr and b_ptr) return a.adjustCondExprPtrs(tok, b, p);
if ((a_ptr and b_nullptr) or (a_nullptr and b_ptr)) {
const nullptr_res = if (a_nullptr) a else b;
const ptr_res = if (a_nullptr) b else a;
try nullptr_res.nullCast(p, ptr_res.ty);
return true;
}
if (a.ty.isRecord() and b.ty.isRecord() and a.ty.eql(b.ty, p.comp, false)) {
return true;
}
return a.invalidBinTy(tok, b, p);
},
.add => {
// if both aren't arithmetic one should be pointer and the other an integer
if (a_ptr == b_ptr or a_int == b_int) return a.invalidBinTy(tok, b, p);
// Do integer promotions but nothing else
if (a_int) try a.intCast(p, a.ty.integerPromotion(p.comp), tok);
if (b_int) try b.intCast(p, b.ty.integerPromotion(p.comp), tok);
// The result type is the type of the pointer operand
if (a_int) a.ty = b.ty else b.ty = a.ty;
return a.shouldEval(b, p);
},
.sub => {
// if both aren't arithmetic then either both should be pointers or just a
if (!a_ptr or !(b_ptr or b_int)) return a.invalidBinTy(tok, b, p);
if (a_ptr and b_ptr) {
if (!a.ty.eql(b.ty, p.comp, false)) try p.errStr(.incompatible_pointers, tok, try p.typePairStr(a.ty, b.ty));
a.ty = p.comp.types.ptrdiff;
}
// Do integer promotion on b if needed
if (b_int) try b.intCast(p, b.ty.integerPromotion(p.comp), tok);
return a.shouldEval(b, p);
},
else => return a.invalidBinTy(tok, b, p),
}
}
fn lvalConversion(res: *Result, p: *Parser) Error!void {
if (res.ty.isFunc()) {
if (res.ty.isInvalidFunc()) {
res.ty = .{ .specifier = .invalid };
} else {
const elem_ty = try p.arena.create(Type);
elem_ty.* = res.ty;
res.ty.specifier = .pointer;
res.ty.data = .{ .sub_type = elem_ty };
}
try res.implicitCast(p, .function_to_pointer);
} else if (res.ty.isArray()) {
res.val = .{};
res.ty.decayArray();
try res.implicitCast(p, .array_to_pointer);
} else if (!p.in_macro and p.tmpTree().isLval(res.node)) {
res.ty.qual = .{};
try res.implicitCast(p, .lval_to_rval);
}
}
fn boolCast(res: *Result, p: *Parser, bool_ty: Type, tok: TokenIndex) Error!void {
if (res.ty.isArray()) {
if (res.val.is(.bytes, p.comp)) {
try p.errStr(.string_literal_to_bool, tok, try p.typePairStrExtra(res.ty, " to ", bool_ty));
} else {
try p.errStr(.array_address_to_bool, tok, p.tokSlice(tok));
}
try res.lvalConversion(p);
res.val = Value.one;
res.ty = bool_ty;
try res.implicitCast(p, .pointer_to_bool);
} else if (res.ty.isPtr()) {
res.val.boolCast(p.comp);
res.ty = bool_ty;
try res.implicitCast(p, .pointer_to_bool);
} else if (res.ty.isInt() and !res.ty.is(.bool)) {
res.val.boolCast(p.comp);
res.ty = bool_ty;
try res.implicitCast(p, .int_to_bool);
} else if (res.ty.isFloat()) {
const old_value = res.val;
const value_change_kind = try res.val.floatToInt(bool_ty, p.comp);
try res.floatToIntWarning(p, bool_ty, old_value, value_change_kind, tok);
if (!res.ty.isReal()) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_float_to_real);
}
res.ty = bool_ty;
try res.implicitCast(p, .float_to_bool);
}
}
fn intCast(res: *Result, p: *Parser, int_ty: Type, tok: TokenIndex) Error!void {
if (int_ty.hasIncompleteSize()) return error.ParsingFailed; // Diagnostic already issued
if (res.ty.is(.bool)) {
res.ty = int_ty.makeReal();
try res.implicitCast(p, .bool_to_int);
if (!int_ty.isReal()) {
res.ty = int_ty;
try res.implicitCast(p, .real_to_complex_int);
}
} else if (res.ty.isPtr()) {
res.ty = int_ty.makeReal();
try res.implicitCast(p, .pointer_to_int);
if (!int_ty.isReal()) {
res.ty = int_ty;
try res.implicitCast(p, .real_to_complex_int);
}
} else if (res.ty.isFloat()) {
const old_value = res.val;
const value_change_kind = try res.val.floatToInt(int_ty, p.comp);
try res.floatToIntWarning(p, int_ty, old_value, value_change_kind, tok);
const old_real = res.ty.isReal();
const new_real = int_ty.isReal();
if (old_real and new_real) {
res.ty = int_ty;
try res.implicitCast(p, .float_to_int);
} else if (old_real) {
res.ty = int_ty.makeReal();
try res.implicitCast(p, .float_to_int);
res.ty = int_ty;
try res.implicitCast(p, .real_to_complex_int);
} else if (new_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_float_to_real);
res.ty = int_ty;
try res.implicitCast(p, .float_to_int);
} else {
res.ty = int_ty;
try res.implicitCast(p, .complex_float_to_complex_int);
}
} else if (!res.ty.eql(int_ty, p.comp, true)) {
const old_val = res.val;
const value_change_kind = try res.val.intCast(int_ty, p.comp);
switch (value_change_kind) {
.none => {},
.truncated => try p.errStr(.int_value_changed, tok, try p.valueChangedStr(res, old_val, int_ty)),
.sign_changed => try p.errStr(.sign_conversion, tok, try p.typePairStrExtra(res.ty, " to ", int_ty)),
}
const old_real = res.ty.isReal();
const new_real = int_ty.isReal();
if (old_real and new_real) {
res.ty = int_ty;
try res.implicitCast(p, .int_cast);
} else if (old_real) {
const real_int_ty = int_ty.makeReal();
if (!res.ty.eql(real_int_ty, p.comp, false)) {
res.ty = real_int_ty;
try res.implicitCast(p, .int_cast);
}
res.ty = int_ty;
try res.implicitCast(p, .real_to_complex_int);
} else if (new_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_int_to_real);
res.ty = int_ty;
try res.implicitCast(p, .int_cast);
} else {
res.ty = int_ty;
try res.implicitCast(p, .complex_int_cast);
}
}
}
fn floatToIntWarning(res: *Result, p: *Parser, int_ty: Type, old_value: Value, change_kind: Value.FloatToIntChangeKind, tok: TokenIndex) !void {
switch (change_kind) {
.none => return p.errStr(.float_to_int, tok, try p.typePairStrExtra(res.ty, " to ", int_ty)),
.out_of_range => return p.errStr(.float_out_of_range, tok, try p.typePairStrExtra(res.ty, " to ", int_ty)),
.overflow => return p.errStr(.float_overflow_conversion, tok, try p.typePairStrExtra(res.ty, " to ", int_ty)),
.nonzero_to_zero => return p.errStr(.float_zero_conversion, tok, try p.valueChangedStr(res, old_value, int_ty)),
.value_changed => return p.errStr(.float_value_changed, tok, try p.valueChangedStr(res, old_value, int_ty)),
}
}
fn floatCast(res: *Result, p: *Parser, float_ty: Type) Error!void {
if (res.ty.is(.bool)) {
try res.val.intToFloat(float_ty, p.comp);
res.ty = float_ty.makeReal();
try res.implicitCast(p, .bool_to_float);
if (!float_ty.isReal()) {
res.ty = float_ty;
try res.implicitCast(p, .real_to_complex_float);
}
} else if (res.ty.isInt()) {
try res.val.intToFloat(float_ty, p.comp);
const old_real = res.ty.isReal();
const new_real = float_ty.isReal();
if (old_real and new_real) {
res.ty = float_ty;
try res.implicitCast(p, .int_to_float);
} else if (old_real) {
res.ty = float_ty.makeReal();
try res.implicitCast(p, .int_to_float);
res.ty = float_ty;
try res.implicitCast(p, .real_to_complex_float);
} else if (new_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_int_to_real);
res.ty = float_ty;
try res.implicitCast(p, .int_to_float);
} else {
res.ty = float_ty;
try res.implicitCast(p, .complex_int_to_complex_float);
}
} else if (!res.ty.eql(float_ty, p.comp, true)) {
try res.val.floatCast(float_ty, p.comp);
const old_real = res.ty.isReal();
const new_real = float_ty.isReal();
if (old_real and new_real) {
res.ty = float_ty;
try res.implicitCast(p, .float_cast);
} else if (old_real) {
if (res.ty.floatRank() != float_ty.floatRank()) {
res.ty = float_ty.makeReal();
try res.implicitCast(p, .float_cast);
}
res.ty = float_ty;
try res.implicitCast(p, .real_to_complex_float);
} else if (new_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_float_to_real);
if (res.ty.floatRank() != float_ty.floatRank()) {
res.ty = float_ty;
try res.implicitCast(p, .float_cast);
}
} else {
res.ty = float_ty;
try res.implicitCast(p, .complex_float_cast);
}
}
}
/// Converts a bool or integer to a pointer
fn ptrCast(res: *Result, p: *Parser, ptr_ty: Type) Error!void {
if (res.ty.is(.bool)) {
res.ty = ptr_ty;
try res.implicitCast(p, .bool_to_pointer);
} else if (res.ty.isInt()) {
_ = try res.val.intCast(ptr_ty, p.comp);
res.ty = ptr_ty;
try res.implicitCast(p, .int_to_pointer);
}
}
/// Convert pointer to one with a different child type
fn ptrChildTypeCast(res: *Result, p: *Parser, ptr_ty: Type) Error!void {
res.ty = ptr_ty;
return res.implicitCast(p, .bitcast);
}
fn toVoid(res: *Result, p: *Parser) Error!void {
if (!res.ty.is(.void)) {
res.ty = .{ .specifier = .void };
try res.implicitCast(p, .to_void);
}
}
fn nullCast(res: *Result, p: *Parser, ptr_ty: Type) Error!void {
if (!res.ty.is(.nullptr_t) and !res.val.isZero(p.comp)) return;
res.ty = ptr_ty;
try res.implicitCast(p, .null_to_pointer);
}
fn usualUnaryConversion(res: *Result, p: *Parser, tok: TokenIndex) Error!void {
if (res.ty.isFloat()) fp_eval: {
const eval_method = p.comp.langopts.fp_eval_method orelse break :fp_eval;
switch (eval_method) {
.source => {},
.indeterminate => unreachable,
.double => {
if (res.ty.floatRank() < (Type{ .specifier = .double }).floatRank()) {
const spec: Type.Specifier = if (res.ty.isReal()) .double else .complex_double;
return res.floatCast(p, .{ .specifier = spec });
}
},
.extended => {
if (res.ty.floatRank() < (Type{ .specifier = .long_double }).floatRank()) {
const spec: Type.Specifier = if (res.ty.isReal()) .long_double else .complex_long_double;
return res.floatCast(p, .{ .specifier = spec });
}
},
}
}
if (res.ty.is(.fp16) and !p.comp.langopts.use_native_half_type) {
return res.floatCast(p, .{ .specifier = .float });
}
if (res.ty.isInt()) {
if (p.tmpTree().bitfieldWidth(res.node, true)) |width| {
if (res.ty.bitfieldPromotion(p.comp, width)) |promotion_ty| {
return res.intCast(p, promotion_ty, tok);
}
}
return res.intCast(p, res.ty.integerPromotion(p.comp), tok);
}
}
fn usualArithmeticConversion(a: *Result, b: *Result, p: *Parser, tok: TokenIndex) Error!void {
try a.usualUnaryConversion(p, tok);
try b.usualUnaryConversion(p, tok);
// if either is a float cast to that type
if (a.ty.isFloat() or b.ty.isFloat()) {
const float_types = [6][2]Type.Specifier{
.{ .complex_long_double, .long_double },
.{ .complex_float128, .float128 },
.{ .complex_double, .double },
.{ .complex_float, .float },
// No `_Complex __fp16` type
.{ .invalid, .fp16 },
.{ .complex_float16, .float16 },
};
const a_spec = a.ty.canonicalize(.standard).specifier;
const b_spec = b.ty.canonicalize(.standard).specifier;
if (p.comp.target.cTypeBitSize(.longdouble) == 128) {
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[0])) return;
}
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[1])) return;
if (p.comp.target.cTypeBitSize(.longdouble) == 80) {
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[0])) return;
}
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[2])) return;
if (p.comp.target.cTypeBitSize(.longdouble) == 64) {
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[0])) return;
}
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[3])) return;
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[4])) return;
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[5])) return;
unreachable;
}
if (a.ty.eql(b.ty, p.comp, true)) {
// cast to promoted type
try a.intCast(p, a.ty, tok);
try b.intCast(p, b.ty, tok);
return;
}
const target = a.ty.integerConversion(b.ty, p.comp);
if (!target.isReal()) {
try a.saveValue(p);
try b.saveValue(p);
}
try a.intCast(p, target, tok);
try b.intCast(p, target, tok);
}
fn floatConversion(a: *Result, b: *Result, a_spec: Type.Specifier, b_spec: Type.Specifier, p: *Parser, pair: [2]Type.Specifier) !bool {
if (a_spec == pair[0] or a_spec == pair[1] or
b_spec == pair[0] or b_spec == pair[1])
{
const both_real = a.ty.isReal() and b.ty.isReal();
const res_spec = pair[@intFromBool(both_real)];
const ty = Type{ .specifier = res_spec };
try a.floatCast(p, ty);
try b.floatCast(p, ty);
return true;
}
return false;
}
fn invalidBinTy(a: *Result, tok: TokenIndex, b: *Result, p: *Parser) Error!bool {
try p.errStr(.invalid_bin_types, tok, try p.typePairStr(a.ty, b.ty));
a.val = .{};
b.val = .{};
a.ty = Type.invalid;
return false;
}
fn shouldEval(a: *Result, b: *Result, p: *Parser) Error!bool {
if (p.no_eval) return false;
if (a.val.opt_ref != .none and b.val.opt_ref != .none)
return true;
try a.saveValue(p);
try b.saveValue(p);
return p.no_eval;
}
/// Saves value and replaces it with `.unavailable`.
fn saveValue(res: *Result, p: *Parser) !void {
assert(!p.in_macro);
if (res.val.opt_ref == .none or res.val.opt_ref == .null) return;
if (!p.in_macro) try p.value_map.put(res.node, res.val);
res.val = .{};
}
fn castType(res: *Result, p: *Parser, to: Type, operand_tok: TokenIndex, l_paren: TokenIndex) !void {
var cast_kind: Tree.CastKind = undefined;
if (to.is(.void)) {
// everything can cast to void
cast_kind = .to_void;
res.val = .{};
} else if (to.is(.nullptr_t)) {
if (res.ty.is(.nullptr_t)) {
cast_kind = .no_op;
} else {
try p.errStr(.invalid_object_cast, l_paren, try p.typePairStrExtra(res.ty, " to ", to));
return error.ParsingFailed;
}
} else if (res.ty.is(.nullptr_t)) {
if (to.is(.bool)) {
try res.nullCast(p, res.ty);
res.val.boolCast(p.comp);
res.ty = .{ .specifier = .bool };
try res.implicitCast(p, .pointer_to_bool);
try res.saveValue(p);
} else if (to.isPtr()) {
try res.nullCast(p, to);
} else {
try p.errStr(.invalid_object_cast, l_paren, try p.typePairStrExtra(res.ty, " to ", to));
return error.ParsingFailed;
}
cast_kind = .no_op;
} else if (res.val.isZero(p.comp) and to.isPtr()) {
cast_kind = .null_to_pointer;
} else if (to.isScalar()) cast: {
const old_float = res.ty.isFloat();
const new_float = to.isFloat();
if (new_float and res.ty.isPtr()) {
try p.errStr(.invalid_cast_to_float, l_paren, try p.typeStr(to));
return error.ParsingFailed;
} else if (old_float and to.isPtr()) {
try p.errStr(.invalid_cast_to_pointer, l_paren, try p.typeStr(res.ty));
return error.ParsingFailed;
}
const old_real = res.ty.isReal();
const new_real = to.isReal();
if (to.eql(res.ty, p.comp, false)) {
cast_kind = .no_op;
} else if (to.is(.bool)) {
if (res.ty.isPtr()) {
cast_kind = .pointer_to_bool;
} else if (res.ty.isInt()) {
if (!old_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_int_to_real);
}
cast_kind = .int_to_bool;
} else if (old_float) {
if (!old_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_float_to_real);
}
cast_kind = .float_to_bool;
}
} else if (to.isInt()) {
if (res.ty.is(.bool)) {
if (!new_real) {
res.ty = to.makeReal();
try res.implicitCast(p, .bool_to_int);
cast_kind = .real_to_complex_int;
} else {
cast_kind = .bool_to_int;
}
} else if (res.ty.isInt()) {
if (old_real and new_real) {
cast_kind = .int_cast;
} else if (old_real) {
res.ty = to.makeReal();
try res.implicitCast(p, .int_cast);
cast_kind = .real_to_complex_int;
} else if (new_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_int_to_real);
cast_kind = .int_cast;
} else {
cast_kind = .complex_int_cast;
}
} else if (res.ty.isPtr()) {
if (!new_real) {
res.ty = to.makeReal();
try res.implicitCast(p, .pointer_to_int);
cast_kind = .real_to_complex_int;
} else {
cast_kind = .pointer_to_int;
}
} else if (old_real and new_real) {
cast_kind = .float_to_int;
} else if (old_real) {
res.ty = to.makeReal();
try res.implicitCast(p, .float_to_int);
cast_kind = .real_to_complex_int;
} else if (new_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_float_to_real);
cast_kind = .float_to_int;
} else {
cast_kind = .complex_float_to_complex_int;
}
} else if (to.isPtr()) {
if (res.ty.isArray())
cast_kind = .array_to_pointer
else if (res.ty.isPtr())
cast_kind = .bitcast
else if (res.ty.isFunc())
cast_kind = .function_to_pointer
else if (res.ty.is(.bool))
cast_kind = .bool_to_pointer
else if (res.ty.isInt()) {
if (!old_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_int_to_real);
}
cast_kind = .int_to_pointer;
} else {
try p.errStr(.cond_expr_type, operand_tok, try p.typeStr(res.ty));
return error.ParsingFailed;
}
} else if (new_float) {
if (res.ty.is(.bool)) {
if (!new_real) {
res.ty = to.makeReal();
try res.implicitCast(p, .bool_to_float);
cast_kind = .real_to_complex_float;
} else {
cast_kind = .bool_to_float;
}
} else if (res.ty.isInt()) {
if (old_real and new_real) {
cast_kind = .int_to_float;
} else if (old_real) {
res.ty = to.makeReal();
try res.implicitCast(p, .int_to_float);
cast_kind = .real_to_complex_float;
} else if (new_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_int_to_real);
cast_kind = .int_to_float;
} else {
cast_kind = .complex_int_to_complex_float;
}
} else if (old_real and new_real) {
cast_kind = .float_cast;
} else if (old_real) {
res.ty = to.makeReal();
try res.implicitCast(p, .float_cast);
cast_kind = .real_to_complex_float;
} else if (new_real) {
res.ty = res.ty.makeReal();
try res.implicitCast(p, .complex_float_to_real);
cast_kind = .float_cast;
} else {
cast_kind = .complex_float_cast;
}
}
if (res.val.opt_ref == .none) break :cast;
const old_int = res.ty.isInt() or res.ty.isPtr();
const new_int = to.isInt() or to.isPtr();
if (to.is(.bool)) {
res.val.boolCast(p.comp);
} else if (old_float and new_int) {
if (to.hasIncompleteSize()) {
try p.errStr(.cast_to_incomplete_type, l_paren, try p.typeStr(to));
return error.ParsingFailed;
}
// Explicit cast, no conversion warning
_ = try res.val.floatToInt(to, p.comp);
} else if (new_float and old_int) {
try res.val.intToFloat(to, p.comp);
} else if (new_float and old_float) {
try res.val.floatCast(to, p.comp);
} else if (old_int and new_int) {
if (to.hasIncompleteSize()) {
try p.errStr(.cast_to_incomplete_type, l_paren, try p.typeStr(to));
return error.ParsingFailed;
}
_ = try res.val.intCast(to, p.comp);
}
} else if (to.get(.@"union")) |union_ty| {
if (union_ty.data.record.hasFieldOfType(res.ty, p.comp)) {
cast_kind = .union_cast;
try p.errTok(.gnu_union_cast, l_paren);
} else {
if (union_ty.data.record.isIncomplete()) {
try p.errStr(.cast_to_incomplete_type, l_paren, try p.typeStr(to));
} else {
try p.errStr(.invalid_union_cast, l_paren, try p.typeStr(res.ty));
}
return error.ParsingFailed;
}
} else {
if (to.is(.auto_type)) {
try p.errTok(.invalid_cast_to_auto_type, l_paren);
} else {
try p.errStr(.invalid_cast_type, l_paren, try p.typeStr(to));
}
return error.ParsingFailed;
}
if (to.anyQual()) try p.errStr(.qual_cast, l_paren, try p.typeStr(to));
if (to.isInt() and res.ty.isPtr() and to.sizeCompare(res.ty, p.comp) == .lt) {
try p.errStr(.cast_to_smaller_int, l_paren, try p.typePairStrExtra(to, " from ", res.ty));
}
res.ty = to;
res.ty.qual = .{};
res.node = try p.addNode(.{
.tag = .explicit_cast,
.ty = res.ty,
.data = .{ .cast = .{ .operand = res.node, .kind = cast_kind } },
.loc = @enumFromInt(l_paren),
});
}
fn intFitsInType(res: Result, p: *Parser, ty: Type) !bool {
const max_int = try Value.maxInt(ty, p.comp);
const min_int = try Value.minInt(ty, p.comp);
return res.val.compare(.lte, max_int, p.comp) and
(res.ty.isUnsignedInt(p.comp) or res.val.compare(.gte, min_int, p.comp));
}
const CoerceContext = union(enum) {
assign,
init,
ret,
arg: TokenIndex,
test_coerce,
fn note(c: CoerceContext, p: *Parser) !void {
switch (c) {
.arg => |tok| try p.errTok(.parameter_here, tok),
.test_coerce => unreachable,
else => {},
}
}
fn typePairStr(c: CoerceContext, p: *Parser, dest_ty: Type, src_ty: Type) ![]const u8 {
switch (c) {
.assign, .init => return p.typePairStrExtra(dest_ty, " from incompatible type ", src_ty),
.ret => return p.typePairStrExtra(src_ty, " from a function with incompatible result type ", dest_ty),
.arg => return p.typePairStrExtra(src_ty, " to parameter of incompatible type ", dest_ty),
.test_coerce => unreachable,
}
}
};
/// Perform assignment-like coercion to `dest_ty`.
fn coerce(res: *Result, p: *Parser, dest_ty: Type, tok: TokenIndex, c: CoerceContext) Error!void {
if (res.ty.specifier == .invalid or dest_ty.specifier == .invalid) {
res.ty = Type.invalid;
return;
}
return res.coerceExtra(p, dest_ty, tok, c) catch |er| switch (er) {
error.CoercionFailed => unreachable,
else => |e| return e,
};
}
fn coerceExtra(
res: *Result,
p: *Parser,
dest_ty: Type,
tok: TokenIndex,
c: CoerceContext,
) (Error || error{CoercionFailed})!void {
// Subject of the coercion does not need to be qualified.
var unqual_ty = dest_ty.canonicalize(.standard);
unqual_ty.qual = .{};
if (unqual_ty.is(.nullptr_t)) {
if (res.ty.is(.nullptr_t)) return;
} else if (unqual_ty.is(.bool)) {
if (res.ty.isScalar() and !res.ty.is(.nullptr_t)) {
// this is ridiculous but it's what clang does
try res.boolCast(p, unqual_ty, tok);
return;
}
} else if (unqual_ty.isInt()) {
if (res.ty.isInt() or res.ty.isFloat()) {
try res.intCast(p, unqual_ty, tok);
return;
} else if (res.ty.isPtr()) {
if (c == .test_coerce) return error.CoercionFailed;
try p.errStr(.implicit_ptr_to_int, tok, try p.typePairStrExtra(res.ty, " to ", dest_ty));
try c.note(p);
try res.intCast(p, unqual_ty, tok);
return;
}
} else if (unqual_ty.isFloat()) {
if (res.ty.isInt() or res.ty.isFloat()) {
try res.floatCast(p, unqual_ty);
return;
}
} else if (unqual_ty.isPtr()) {
if (res.ty.is(.nullptr_t) or res.val.isZero(p.comp)) {
try res.nullCast(p, dest_ty);
return;
} else if (res.ty.isInt() and res.ty.isReal()) {
if (c == .test_coerce) return error.CoercionFailed;
try p.errStr(.implicit_int_to_ptr, tok, try p.typePairStrExtra(res.ty, " to ", dest_ty));
try c.note(p);
try res.ptrCast(p, unqual_ty);
return;
} else if (res.ty.isVoidStar() or unqual_ty.eql(res.ty, p.comp, true)) {
return; // ok
} else if (unqual_ty.isVoidStar() and res.ty.isPtr() or (res.ty.isInt() and res.ty.isReal())) {
return; // ok
} else if (unqual_ty.eql(res.ty, p.comp, false)) {
if (!unqual_ty.elemType().qual.hasQuals(res.ty.elemType().qual)) {
try p.errStr(switch (c) {
.assign => .ptr_assign_discards_quals,
.init => .ptr_init_discards_quals,
.ret => .ptr_ret_discards_quals,
.arg => .ptr_arg_discards_quals,
.test_coerce => return error.CoercionFailed,
}, tok, try c.typePairStr(p, dest_ty, res.ty));
}
try res.ptrCast(p, unqual_ty);
return;
} else if (res.ty.isPtr()) {
const different_sign_only = unqual_ty.elemType().sameRankDifferentSign(res.ty.elemType(), p.comp);
try p.errStr(switch (c) {
.assign => ([2]Diagnostics.Tag{ .incompatible_ptr_assign, .incompatible_ptr_assign_sign })[@intFromBool(different_sign_only)],
.init => ([2]Diagnostics.Tag{ .incompatible_ptr_init, .incompatible_ptr_init_sign })[@intFromBool(different_sign_only)],
.ret => ([2]Diagnostics.Tag{ .incompatible_return, .incompatible_return_sign })[@intFromBool(different_sign_only)],
.arg => ([2]Diagnostics.Tag{ .incompatible_ptr_arg, .incompatible_ptr_arg_sign })[@intFromBool(different_sign_only)],
.test_coerce => return error.CoercionFailed,
}, tok, try c.typePairStr(p, dest_ty, res.ty));
try c.note(p);
try res.ptrChildTypeCast(p, unqual_ty);
return;
}
} else if (unqual_ty.isRecord()) {
if (unqual_ty.eql(res.ty, p.comp, false)) {
return; // ok
}
if (c == .arg) if (unqual_ty.get(.@"union")) |union_ty| {
if (dest_ty.hasAttribute(.transparent_union)) transparent_union: {
res.coerceExtra(p, union_ty.data.record.fields[0].ty, tok, .test_coerce) catch |er| switch (er) {
error.CoercionFailed => break :transparent_union,
else => |e| return e,
};
res.node = try p.addNode(.{
.tag = .union_init_expr,
.ty = dest_ty,
.data = .{ .union_init = .{ .field_index = 0, .node = res.node } },
});
res.ty = dest_ty;
return;
}
};
} else if (unqual_ty.is(.vector)) {
if (unqual_ty.eql(res.ty, p.comp, false)) {
return; // ok
}
} else {
if (c == .assign and (unqual_ty.isArray() or unqual_ty.isFunc())) {
try p.errTok(.not_assignable, tok);
return;
} else if (c == .test_coerce) {
return error.CoercionFailed;
}
// This case should not be possible and an error should have already been emitted but we
// might still have attempted to parse further so return error.ParsingFailed here to stop.
return error.ParsingFailed;
}
try p.errStr(switch (c) {
.assign => .incompatible_assign,
.init => .incompatible_init,
.ret => .incompatible_return,
.arg => .incompatible_arg,
.test_coerce => return error.CoercionFailed,
}, tok, try c.typePairStr(p, dest_ty, res.ty));
try c.note(p);
}
};
/// expr : assignExpr (',' assignExpr)*
fn expr(p: *Parser) Error!Result {
var expr_start = p.tok_i;
var err_start = p.comp.diagnostics.list.items.len;
var lhs = try p.assignExpr();
if (p.tok_ids[p.tok_i] == .comma) try lhs.expect(p);
while (p.eatToken(.comma)) |comma| {
try lhs.maybeWarnUnused(p, expr_start, err_start);
expr_start = p.tok_i;
err_start = p.comp.diagnostics.list.items.len;
var rhs = try p.assignExpr();
try rhs.expect(p);
try rhs.lvalConversion(p);
lhs.val = rhs.val;
lhs.ty = rhs.ty;
try lhs.bin(p, .comma_expr, rhs, comma);
}
return lhs;
}
fn tokToTag(p: *Parser, tok: TokenIndex) Tree.Tag {
return switch (p.tok_ids[tok]) {
.equal => .assign_expr,
.asterisk_equal => .mul_assign_expr,
.slash_equal => .div_assign_expr,
.percent_equal => .mod_assign_expr,
.plus_equal => .add_assign_expr,
.minus_equal => .sub_assign_expr,
.angle_bracket_angle_bracket_left_equal => .shl_assign_expr,
.angle_bracket_angle_bracket_right_equal => .shr_assign_expr,
.ampersand_equal => .bit_and_assign_expr,
.caret_equal => .bit_xor_assign_expr,
.pipe_equal => .bit_or_assign_expr,
.equal_equal => .equal_expr,
.bang_equal => .not_equal_expr,
.angle_bracket_left => .less_than_expr,
.angle_bracket_left_equal => .less_than_equal_expr,
.angle_bracket_right => .greater_than_expr,
.angle_bracket_right_equal => .greater_than_equal_expr,
.angle_bracket_angle_bracket_left => .shl_expr,
.angle_bracket_angle_bracket_right => .shr_expr,
.plus => .add_expr,
.minus => .sub_expr,
.asterisk => .mul_expr,
.slash => .div_expr,
.percent => .mod_expr,
else => unreachable,
};
}
/// assignExpr
/// : condExpr
/// | unExpr ('=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | '^=' | '|=') assignExpr
fn assignExpr(p: *Parser) Error!Result {
var lhs = try p.condExpr();
if (lhs.empty(p)) return lhs;
const tok = p.tok_i;
const eq = p.eatToken(.equal);
const mul = eq orelse p.eatToken(.asterisk_equal);
const div = mul orelse p.eatToken(.slash_equal);
const mod = div orelse p.eatToken(.percent_equal);
const add = mod orelse p.eatToken(.plus_equal);
const sub = add orelse p.eatToken(.minus_equal);
const shl = sub orelse p.eatToken(.angle_bracket_angle_bracket_left_equal);
const shr = shl orelse p.eatToken(.angle_bracket_angle_bracket_right_equal);
const bit_and = shr orelse p.eatToken(.ampersand_equal);
const bit_xor = bit_and orelse p.eatToken(.caret_equal);
const bit_or = bit_xor orelse p.eatToken(.pipe_equal);
const tag = p.tokToTag(bit_or orelse return lhs);
var rhs = try p.assignExpr();
try rhs.expect(p);
try rhs.lvalConversion(p);
var is_const: bool = undefined;
if (!p.tmpTree().isLvalExtra(lhs.node, &is_const) or is_const) {
try p.errTok(.not_assignable, tok);
return error.ParsingFailed;
}
// adjustTypes will do do lvalue conversion but we do not want that
var lhs_copy = lhs;
switch (tag) {
.assign_expr => {}, // handle plain assignment separately
.mul_assign_expr,
.div_assign_expr,
.mod_assign_expr,
=> {
if (rhs.val.isZero(p.comp) and lhs.ty.isInt() and rhs.ty.isInt()) {
switch (tag) {
.div_assign_expr => try p.errStr(.division_by_zero, div.?, "division"),
.mod_assign_expr => try p.errStr(.division_by_zero, mod.?, "remainder"),
else => {},
}
}
_ = try lhs_copy.adjustTypes(tok, &rhs, p, if (tag == .mod_assign_expr) .integer else .arithmetic);
try lhs.bin(p, tag, rhs, bit_or.?);
return lhs;
},
.sub_assign_expr,
.add_assign_expr,
=> {
if (lhs.ty.isPtr() and rhs.ty.isInt()) {
try rhs.ptrCast(p, lhs.ty);
} else {
_ = try lhs_copy.adjustTypes(tok, &rhs, p, .arithmetic);
}
try lhs.bin(p, tag, rhs, bit_or.?);
return lhs;
},
.shl_assign_expr,
.shr_assign_expr,
.bit_and_assign_expr,
.bit_xor_assign_expr,
.bit_or_assign_expr,
=> {
_ = try lhs_copy.adjustTypes(tok, &rhs, p, .integer);
try lhs.bin(p, tag, rhs, bit_or.?);
return lhs;
},
else => unreachable,
}
try rhs.coerce(p, lhs.ty, tok, .assign);
try lhs.bin(p, tag, rhs, bit_or.?);
return lhs;
}
/// Returns a parse error if the expression is not an integer constant
/// integerConstExpr : constExpr
fn integerConstExpr(p: *Parser, decl_folding: ConstDeclFoldingMode) Error!Result {
const start = p.tok_i;
const res = try p.constExpr(decl_folding);
if (!res.ty.isInt() and res.ty.specifier != .invalid) {
try p.errTok(.expected_integer_constant_expr, start);
return error.ParsingFailed;
}
return res;
}
/// Caller is responsible for issuing a diagnostic if result is invalid/unavailable
/// constExpr : condExpr
fn constExpr(p: *Parser, decl_folding: ConstDeclFoldingMode) Error!Result {
const const_decl_folding = p.const_decl_folding;
defer p.const_decl_folding = const_decl_folding;
p.const_decl_folding = decl_folding;
const res = try p.condExpr();
try res.expect(p);
if (res.ty.specifier == .invalid or res.val.opt_ref == .none) return res;
// saveValue sets val to unavailable
var copy = res;
try copy.saveValue(p);
return res;
}
/// condExpr : lorExpr ('?' expression? ':' condExpr)?
fn condExpr(p: *Parser) Error!Result {
const cond_tok = p.tok_i;
var cond = try p.lorExpr();
if (cond.empty(p) or p.eatToken(.question_mark) == null) return cond;
try cond.lvalConversion(p);
const saved_eval = p.no_eval;
if (!cond.ty.isScalar()) {
try p.errStr(.cond_expr_type, cond_tok, try p.typeStr(cond.ty));
return error.ParsingFailed;
}
// Prepare for possible binary conditional expression.
const maybe_colon = p.eatToken(.colon);
// Depending on the value of the condition, avoid evaluating unreachable branches.
var then_expr = blk: {
defer p.no_eval = saved_eval;
if (cond.val.opt_ref != .none and !cond.val.toBool(p.comp)) p.no_eval = true;
break :blk try p.expr();
};
try then_expr.expect(p);
// If we saw a colon then this is a binary conditional expression.
if (maybe_colon) |colon| {
var cond_then = cond;
cond_then.node = try p.addNode(.{ .tag = .cond_dummy_expr, .ty = cond.ty, .data = .{ .un = cond.node } });
_ = try cond_then.adjustTypes(colon, &then_expr, p, .conditional);
cond.ty = then_expr.ty;
cond.node = try p.addNode(.{
.tag = .binary_cond_expr,
.ty = cond.ty,
.data = .{ .if3 = .{ .cond = cond.node, .body = (try p.addList(&.{ cond_then.node, then_expr.node })).start } },
.loc = @enumFromInt(cond_tok),
});
return cond;
}
const colon = try p.expectToken(.colon);
var else_expr = blk: {
defer p.no_eval = saved_eval;
if (cond.val.opt_ref != .none and cond.val.toBool(p.comp)) p.no_eval = true;
break :blk try p.condExpr();
};
try else_expr.expect(p);
_ = try then_expr.adjustTypes(colon, &else_expr, p, .conditional);
if (cond.val.opt_ref != .none) {
cond.val = if (cond.val.toBool(p.comp)) then_expr.val else else_expr.val;
} else {
try then_expr.saveValue(p);
try else_expr.saveValue(p);
}
cond.ty = then_expr.ty;
cond.node = try p.addNode(.{
.tag = .cond_expr,
.ty = cond.ty,
.data = .{ .if3 = .{ .cond = cond.node, .body = (try p.addList(&.{ then_expr.node, else_expr.node })).start } },
.loc = @enumFromInt(cond_tok),
});
return cond;
}
/// lorExpr : landExpr ('||' landExpr)*
fn lorExpr(p: *Parser) Error!Result {
var lhs = try p.landExpr();
if (lhs.empty(p)) return lhs;
const saved_eval = p.no_eval;
defer p.no_eval = saved_eval;
while (p.eatToken(.pipe_pipe)) |tok| {
if (lhs.val.opt_ref != .none and lhs.val.toBool(p.comp)) p.no_eval = true;
var rhs = try p.landExpr();
try rhs.expect(p);
if (try lhs.adjustTypes(tok, &rhs, p, .boolean_logic)) {
const res = lhs.val.toBool(p.comp) or rhs.val.toBool(p.comp);
lhs.val = Value.fromBool(res);
} else {
lhs.val.boolCast(p.comp);
}
try lhs.boolRes(p, .bool_or_expr, rhs, tok);
}
return lhs;
}
/// landExpr : orExpr ('&&' orExpr)*
fn landExpr(p: *Parser) Error!Result {
var lhs = try p.orExpr();
if (lhs.empty(p)) return lhs;
const saved_eval = p.no_eval;
defer p.no_eval = saved_eval;
while (p.eatToken(.ampersand_ampersand)) |tok| {
if (lhs.val.opt_ref != .none and !lhs.val.toBool(p.comp)) p.no_eval = true;
var rhs = try p.orExpr();
try rhs.expect(p);
if (try lhs.adjustTypes(tok, &rhs, p, .boolean_logic)) {
const res = lhs.val.toBool(p.comp) and rhs.val.toBool(p.comp);
lhs.val = Value.fromBool(res);
} else {
lhs.val.boolCast(p.comp);
}
try lhs.boolRes(p, .bool_and_expr, rhs, tok);
}
return lhs;
}
/// orExpr : xorExpr ('|' xorExpr)*
fn orExpr(p: *Parser) Error!Result {
var lhs = try p.xorExpr();
if (lhs.empty(p)) return lhs;
while (p.eatToken(.pipe)) |tok| {
var rhs = try p.xorExpr();
try rhs.expect(p);
if (try lhs.adjustTypes(tok, &rhs, p, .integer)) {
lhs.val = try lhs.val.bitOr(rhs.val, p.comp);
}
try lhs.bin(p, .bit_or_expr, rhs, tok);
}
return lhs;
}
/// xorExpr : andExpr ('^' andExpr)*
fn xorExpr(p: *Parser) Error!Result {
var lhs = try p.andExpr();
if (lhs.empty(p)) return lhs;
while (p.eatToken(.caret)) |tok| {
var rhs = try p.andExpr();
try rhs.expect(p);
if (try lhs.adjustTypes(tok, &rhs, p, .integer)) {
lhs.val = try lhs.val.bitXor(rhs.val, p.comp);
}
try lhs.bin(p, .bit_xor_expr, rhs, tok);
}
return lhs;
}
/// andExpr : eqExpr ('&' eqExpr)*
fn andExpr(p: *Parser) Error!Result {
var lhs = try p.eqExpr();
if (lhs.empty(p)) return lhs;
while (p.eatToken(.ampersand)) |tok| {
var rhs = try p.eqExpr();
try rhs.expect(p);
if (try lhs.adjustTypes(tok, &rhs, p, .integer)) {
lhs.val = try lhs.val.bitAnd(rhs.val, p.comp);
}
try lhs.bin(p, .bit_and_expr, rhs, tok);
}
return lhs;
}
/// eqExpr : compExpr (('==' | '!=') compExpr)*
fn eqExpr(p: *Parser) Error!Result {
var lhs = try p.compExpr();
if (lhs.empty(p)) return lhs;
while (true) {
const eq = p.eatToken(.equal_equal);
const ne = eq orelse p.eatToken(.bang_equal);
const tag = p.tokToTag(ne orelse break);
var rhs = try p.compExpr();
try rhs.expect(p);
if (try lhs.adjustTypes(ne.?, &rhs, p, .equality)) {
const op: std.math.CompareOperator = if (tag == .equal_expr) .eq else .neq;
const res = lhs.val.compare(op, rhs.val, p.comp);
lhs.val = Value.fromBool(res);
} else {
lhs.val.boolCast(p.comp);
}
try lhs.boolRes(p, tag, rhs, ne.?);
}
return lhs;
}
/// compExpr : shiftExpr (('<' | '<=' | '>' | '>=') shiftExpr)*
fn compExpr(p: *Parser) Error!Result {
var lhs = try p.shiftExpr();
if (lhs.empty(p)) return lhs;
while (true) {
const lt = p.eatToken(.angle_bracket_left);
const le = lt orelse p.eatToken(.angle_bracket_left_equal);
const gt = le orelse p.eatToken(.angle_bracket_right);
const ge = gt orelse p.eatToken(.angle_bracket_right_equal);
const tag = p.tokToTag(ge orelse break);
var rhs = try p.shiftExpr();
try rhs.expect(p);
if (try lhs.adjustTypes(ge.?, &rhs, p, .relational)) {
const op: std.math.CompareOperator = switch (tag) {
.less_than_expr => .lt,
.less_than_equal_expr => .lte,
.greater_than_expr => .gt,
.greater_than_equal_expr => .gte,
else => unreachable,
};
const res = lhs.val.compare(op, rhs.val, p.comp);
lhs.val = Value.fromBool(res);
} else {
lhs.val.boolCast(p.comp);
}
try lhs.boolRes(p, tag, rhs, ge.?);
}
return lhs;
}
/// shiftExpr : addExpr (('<<' | '>>') addExpr)*
fn shiftExpr(p: *Parser) Error!Result {
var lhs = try p.addExpr();
if (lhs.empty(p)) return lhs;
while (true) {
const shl = p.eatToken(.angle_bracket_angle_bracket_left);
const shr = shl orelse p.eatToken(.angle_bracket_angle_bracket_right);
const tag = p.tokToTag(shr orelse break);
var rhs = try p.addExpr();
try rhs.expect(p);
if (try lhs.adjustTypes(shr.?, &rhs, p, .integer)) {
if (rhs.val.compare(.lt, Value.zero, p.comp)) {
try p.errStr(.negative_shift_count, shl orelse shr.?, try rhs.str(p));
}
if (rhs.val.compare(.gte, try Value.int(lhs.ty.bitSizeof(p.comp).?, p.comp), p.comp)) {
try p.errStr(.too_big_shift_count, shl orelse shr.?, try rhs.str(p));
}
if (shl != null) {
if (try lhs.val.shl(lhs.val, rhs.val, lhs.ty, p.comp) and
lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(shl.?, lhs);
} else {
lhs.val = try lhs.val.shr(rhs.val, lhs.ty, p.comp);
}
}
try lhs.bin(p, tag, rhs, shr.?);
}
return lhs;
}
/// addExpr : mulExpr (('+' | '-') mulExpr)*
fn addExpr(p: *Parser) Error!Result {
var lhs = try p.mulExpr();
if (lhs.empty(p)) return lhs;
while (true) {
const plus = p.eatToken(.plus);
const minus = plus orelse p.eatToken(.minus);
const tag = p.tokToTag(minus orelse break);
var rhs = try p.mulExpr();
try rhs.expect(p);
const lhs_ty = lhs.ty;
if (try lhs.adjustTypes(minus.?, &rhs, p, if (plus != null) .add else .sub)) {
if (plus != null) {
if (try lhs.val.add(lhs.val, rhs.val, lhs.ty, p.comp) and
lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(plus.?, lhs);
} else {
if (try lhs.val.sub(lhs.val, rhs.val, lhs.ty, p.comp) and
lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(minus.?, lhs);
}
}
if (lhs.ty.specifier != .invalid and lhs_ty.isPtr() and !lhs_ty.isVoidStar() and lhs_ty.elemType().hasIncompleteSize()) {
try p.errStr(.ptr_arithmetic_incomplete, minus.?, try p.typeStr(lhs_ty.elemType()));
lhs.ty = Type.invalid;
}
try lhs.bin(p, tag, rhs, minus.?);
}
return lhs;
}
/// mulExpr : castExpr (('*' | '/' | '%') castExpr)*´
fn mulExpr(p: *Parser) Error!Result {
var lhs = try p.castExpr();
if (lhs.empty(p)) return lhs;
while (true) {
const mul = p.eatToken(.asterisk);
const div = mul orelse p.eatToken(.slash);
const percent = div orelse p.eatToken(.percent);
const tag = p.tokToTag(percent orelse break);
var rhs = try p.castExpr();
try rhs.expect(p);
if (rhs.val.isZero(p.comp) and mul == null and !p.no_eval and lhs.ty.isInt() and rhs.ty.isInt()) {
const err_tag: Diagnostics.Tag = if (p.in_macro) .division_by_zero_macro else .division_by_zero;
lhs.val = .{};
if (div != null) {
try p.errStr(err_tag, div.?, "division");
} else {
try p.errStr(err_tag, percent.?, "remainder");
}
if (p.in_macro) return error.ParsingFailed;
}
if (try lhs.adjustTypes(percent.?, &rhs, p, if (tag == .mod_expr) .integer else .arithmetic)) {
if (mul != null) {
if (try lhs.val.mul(lhs.val, rhs.val, lhs.ty, p.comp) and
lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(mul.?, lhs);
} else if (div != null) {
if (try lhs.val.div(lhs.val, rhs.val, lhs.ty, p.comp) and
lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(div.?, lhs);
} else {
var res = try Value.rem(lhs.val, rhs.val, lhs.ty, p.comp);
if (res.opt_ref == .none) {
if (p.in_macro) {
// match clang behavior by defining invalid remainder to be zero in macros
res = Value.zero;
} else {
try lhs.saveValue(p);
try rhs.saveValue(p);
}
}
lhs.val = res;
}
}
try lhs.bin(p, tag, rhs, percent.?);
}
return lhs;
}
/// This will always be the last message, if present
fn removeUnusedWarningForTok(p: *Parser, last_expr_tok: TokenIndex) void {
if (last_expr_tok == 0) return;
if (p.comp.diagnostics.list.items.len == 0) return;
const last_expr_loc = p.pp.tokens.items(.loc)[last_expr_tok];
const last_msg = p.comp.diagnostics.list.items[p.comp.diagnostics.list.items.len - 1];
if (last_msg.tag == .unused_value and last_msg.loc.eql(last_expr_loc)) {
p.comp.diagnostics.list.items.len = p.comp.diagnostics.list.items.len - 1;
}
}
/// castExpr
/// : '(' compoundStmt ')' suffixExpr*
/// | '(' typeName ')' castExpr
/// | '(' typeName ')' '{' initializerItems '}'
/// | __builtin_choose_expr '(' integerConstExpr ',' assignExpr ',' assignExpr ')'
/// | __builtin_va_arg '(' assignExpr ',' typeName ')'
/// | __builtin_offsetof '(' typeName ',' offsetofMemberDesignator ')'
/// | __builtin_bitoffsetof '(' typeName ',' offsetofMemberDesignator ')'
/// | unExpr
fn castExpr(p: *Parser) Error!Result {
if (p.eatToken(.l_paren)) |l_paren| cast_expr: {
if (p.tok_ids[p.tok_i] == .l_brace) {
const tok = p.tok_i;
try p.err(.gnu_statement_expression);
if (p.func.ty == null) {
try p.err(.stmt_expr_not_allowed_file_scope);
return error.ParsingFailed;
}
var stmt_expr_state: StmtExprState = .{};
const body_node = (try p.compoundStmt(false, &stmt_expr_state)).?; // compoundStmt only returns null if .l_brace isn't the first token
p.removeUnusedWarningForTok(stmt_expr_state.last_expr_tok);
var res = Result{
.node = body_node,
.ty = stmt_expr_state.last_expr_res.ty,
.val = stmt_expr_state.last_expr_res.val,
};
try p.expectClosing(l_paren, .r_paren);
try res.un(p, .stmt_expr, tok);
while (true) {
const suffix = try p.suffixExpr(res);
if (suffix.empty(p)) break;
res = suffix;
}
return res;
}
const ty = (try p.typeName()) orelse {
p.tok_i -= 1;
break :cast_expr;
};
try p.expectClosing(l_paren, .r_paren);
if (p.tok_ids[p.tok_i] == .l_brace) {
// Compound literal; handled in unExpr
p.tok_i = l_paren;
break :cast_expr;
}
const operand_tok = p.tok_i;
var operand = try p.castExpr();
try operand.expect(p);
try operand.lvalConversion(p);
try operand.castType(p, ty, operand_tok, l_paren);
return operand;
}
switch (p.tok_ids[p.tok_i]) {
.builtin_choose_expr => return p.builtinChooseExpr(),
.builtin_va_arg => return p.builtinVaArg(),
.builtin_offsetof => return p.builtinOffsetof(false),
.builtin_bitoffsetof => return p.builtinOffsetof(true),
.builtin_types_compatible_p => return p.typesCompatible(),
// TODO: other special-cased builtins
else => {},
}
return p.unExpr();
}
fn typesCompatible(p: *Parser) Error!Result {
const builtin_tok = p.tok_i;
p.tok_i += 1;
const l_paren = try p.expectToken(.l_paren);
const first_tok = p.tok_i;
const first = (try p.typeName()) orelse {
try p.err(.expected_type);
p.skipTo(.r_paren);
return error.ParsingFailed;
};
const lhs = try p.addNode(.{ .tag = .invalid, .ty = first, .data = undefined, .loc = @enumFromInt(first_tok) });
_ = try p.expectToken(.comma);
const second_tok = p.tok_i;
const second = (try p.typeName()) orelse {
try p.err(.expected_type);
p.skipTo(.r_paren);
return error.ParsingFailed;
};
const rhs = try p.addNode(.{ .tag = .invalid, .ty = second, .data = undefined, .loc = @enumFromInt(second_tok) });
try p.expectClosing(l_paren, .r_paren);
var first_unqual = first.canonicalize(.standard);
first_unqual.qual.@"const" = false;
first_unqual.qual.@"volatile" = false;
var second_unqual = second.canonicalize(.standard);
second_unqual.qual.@"const" = false;
second_unqual.qual.@"volatile" = false;
const compatible = first_unqual.eql(second_unqual, p.comp, true);
const res = Result{
.val = Value.fromBool(compatible),
.node = try p.addNode(.{
.tag = .builtin_types_compatible_p,
.ty = Type.int,
.data = .{ .bin = .{
.lhs = lhs,
.rhs = rhs,
} },
.loc = @enumFromInt(builtin_tok),
}),
};
try p.value_map.put(res.node, res.val);
return res;
}
fn builtinChooseExpr(p: *Parser) Error!Result {
p.tok_i += 1;
const l_paren = try p.expectToken(.l_paren);
const cond_tok = p.tok_i;
var cond = try p.integerConstExpr(.no_const_decl_folding);
if (cond.val.opt_ref == .none) {
try p.errTok(.builtin_choose_cond, cond_tok);
return error.ParsingFailed;
}
_ = try p.expectToken(.comma);
var then_expr = if (cond.val.toBool(p.comp)) try p.assignExpr() else try p.parseNoEval(assignExpr);
try then_expr.expect(p);
_ = try p.expectToken(.comma);
var else_expr = if (!cond.val.toBool(p.comp)) try p.assignExpr() else try p.parseNoEval(assignExpr);
try else_expr.expect(p);
try p.expectClosing(l_paren, .r_paren);
if (cond.val.toBool(p.comp)) {
cond.val = then_expr.val;
cond.ty = then_expr.ty;
} else {
cond.val = else_expr.val;
cond.ty = else_expr.ty;
}
cond.node = try p.addNode(.{
.tag = .builtin_choose_expr,
.ty = cond.ty,
.data = .{ .if3 = .{ .cond = cond.node, .body = (try p.addList(&.{ then_expr.node, else_expr.node })).start } },
});
return cond;
}
fn builtinVaArg(p: *Parser) Error!Result {
const builtin_tok = p.tok_i;
p.tok_i += 1;
const l_paren = try p.expectToken(.l_paren);
const va_list_tok = p.tok_i;
var va_list = try p.assignExpr();
try va_list.expect(p);
try va_list.lvalConversion(p);
_ = try p.expectToken(.comma);
const ty = (try p.typeName()) orelse {
try p.err(.expected_type);
return error.ParsingFailed;
};
try p.expectClosing(l_paren, .r_paren);
if (!va_list.ty.eql(p.comp.types.va_list, p.comp, true)) {
try p.errStr(.incompatible_va_arg, va_list_tok, try p.typeStr(va_list.ty));
return error.ParsingFailed;
}
return Result{ .ty = ty, .node = try p.addNode(.{
.tag = .special_builtin_call_one,
.ty = ty,
.data = .{ .decl = .{ .name = builtin_tok, .node = va_list.node } },
}) };
}
fn builtinOffsetof(p: *Parser, want_bits: bool) Error!Result {
const builtin_tok = p.tok_i;
p.tok_i += 1;
const l_paren = try p.expectToken(.l_paren);
const ty_tok = p.tok_i;
const ty = (try p.typeName()) orelse {
try p.err(.expected_type);
p.skipTo(.r_paren);
return error.ParsingFailed;
};
if (!ty.isRecord()) {
try p.errStr(.offsetof_ty, ty_tok, try p.typeStr(ty));
p.skipTo(.r_paren);
return error.ParsingFailed;
} else if (ty.hasIncompleteSize()) {
try p.errStr(.offsetof_incomplete, ty_tok, try p.typeStr(ty));
p.skipTo(.r_paren);
return error.ParsingFailed;
}
_ = try p.expectToken(.comma);
const offsetof_expr = try p.offsetofMemberDesignator(ty, want_bits);
try p.expectClosing(l_paren, .r_paren);
return Result{
.ty = p.comp.types.size,
.val = offsetof_expr.val,
.node = try p.addNode(.{
.tag = .special_builtin_call_one,
.ty = p.comp.types.size,
.data = .{ .decl = .{ .name = builtin_tok, .node = offsetof_expr.node } },
}),
};
}
/// offsetofMemberDesignator: IDENTIFIER ('.' IDENTIFIER | '[' expr ']' )*
fn offsetofMemberDesignator(p: *Parser, base_ty: Type, want_bits: bool) Error!Result {
errdefer p.skipTo(.r_paren);
const base_field_name_tok = try p.expectIdentifier();
const base_field_name = try StrInt.intern(p.comp, p.tokSlice(base_field_name_tok));
const base_record_ty = base_ty.getRecord().?;
try p.validateFieldAccess(base_record_ty, base_ty, base_field_name_tok, base_field_name);
const base_node = try p.addNode(.{ .tag = .default_init_expr, .ty = base_ty, .data = undefined });
var cur_offset: u64 = 0;
var lhs = try p.fieldAccessExtra(base_node, base_record_ty, base_field_name, false, &cur_offset);
var total_offset = cur_offset;
while (true) switch (p.tok_ids[p.tok_i]) {
.period => {
p.tok_i += 1;
const field_name_tok = try p.expectIdentifier();
const field_name = try StrInt.intern(p.comp, p.tokSlice(field_name_tok));
const lhs_record_ty = lhs.ty.getRecord() orelse {
try p.errStr(.offsetof_ty, field_name_tok, try p.typeStr(lhs.ty));
return error.ParsingFailed;
};
try p.validateFieldAccess(lhs_record_ty, lhs.ty, field_name_tok, field_name);
lhs = try p.fieldAccessExtra(lhs.node, lhs_record_ty, field_name, false, &cur_offset);
total_offset += cur_offset;
},
.l_bracket => {
const l_bracket_tok = p.tok_i;
p.tok_i += 1;
var index = try p.expr();
try index.expect(p);
_ = try p.expectClosing(l_bracket_tok, .r_bracket);
if (!lhs.ty.isArray()) {
try p.errStr(.offsetof_array, l_bracket_tok, try p.typeStr(lhs.ty));
return error.ParsingFailed;
}
var ptr = lhs;
try ptr.lvalConversion(p);
try index.lvalConversion(p);
if (index.ty.isInt()) {
try p.checkArrayBounds(index, lhs, l_bracket_tok);
} else {
try p.errTok(.invalid_index, l_bracket_tok);
}
try index.saveValue(p);
try ptr.bin(p, .array_access_expr, index, l_bracket_tok);
lhs = ptr;
},
else => break,
};
const val = try Value.int(if (want_bits) total_offset else total_offset / 8, p.comp);
return Result{ .ty = base_ty, .val = val, .node = lhs.node };
}
/// unExpr
/// : (compoundLiteral | primaryExpr) suffixExpr*
/// | '&&' IDENTIFIER
/// | ('&' | '*' | '+' | '-' | '~' | '!' | '++' | '--' | keyword_extension | keyword_imag | keyword_real) castExpr
/// | keyword_sizeof unExpr
/// | keyword_sizeof '(' typeName ')'
/// | keyword_alignof '(' typeName ')'
/// | keyword_c23_alignof '(' typeName ')'
fn unExpr(p: *Parser) Error!Result {
const tok = p.tok_i;
switch (p.tok_ids[tok]) {
.ampersand_ampersand => {
const address_tok = p.tok_i;
p.tok_i += 1;
const name_tok = try p.expectIdentifier();
try p.errTok(.gnu_label_as_value, address_tok);
p.contains_address_of_label = true;
const str = p.tokSlice(name_tok);
if (p.findLabel(str) == null) {
try p.labels.append(.{ .unresolved_goto = name_tok });
}
const elem_ty = try p.arena.create(Type);
elem_ty.* = .{ .specifier = .void };
const result_ty = Type{ .specifier = .pointer, .data = .{ .sub_type = elem_ty } };
return Result{
.node = try p.addNode(.{
.tag = .addr_of_label,
.data = .{ .decl_ref = name_tok },
.ty = result_ty,
.loc = @enumFromInt(address_tok),
}),
.ty = result_ty,
};
},
.ampersand => {
if (p.in_macro) {
try p.err(.invalid_preproc_operator);
return error.ParsingFailed;
}
p.tok_i += 1;
var operand = try p.castExpr();
try operand.expect(p);
const tree = p.tmpTree();
if (p.getNode(operand.node, .member_access_expr) orelse
p.getNode(operand.node, .member_access_ptr_expr)) |member_node|
{
if (tree.isBitfield(member_node)) try p.errTok(.addr_of_bitfield, tok);
}
if (!tree.isLval(operand.node) and !operand.ty.is(.invalid)) {
try p.errTok(.addr_of_rvalue, tok);
}
if (operand.ty.qual.register) try p.errTok(.addr_of_register, tok);
if (!operand.ty.is(.invalid)) {
const elem_ty = try p.arena.create(Type);
elem_ty.* = operand.ty;
operand.ty = Type{
.specifier = .pointer,
.data = .{ .sub_type = elem_ty },
};
}
try operand.saveValue(p);
try operand.un(p, .addr_of_expr, tok);
return operand;
},
.asterisk => {
const asterisk_loc = p.tok_i;
p.tok_i += 1;
var operand = try p.castExpr();
try operand.expect(p);
if (operand.ty.isArray() or operand.ty.isPtr() or operand.ty.isFunc()) {
try operand.lvalConversion(p);
operand.ty = operand.ty.elemType();
} else {
try p.errTok(.indirection_ptr, tok);
}
if (operand.ty.hasIncompleteSize() and !operand.ty.is(.void)) {
try p.errStr(.deref_incomplete_ty_ptr, asterisk_loc, try p.typeStr(operand.ty));
}
operand.ty.qual = .{};
try operand.un(p, .deref_expr, tok);
return operand;
},
.plus => {
p.tok_i += 1;
var operand = try p.castExpr();
try operand.expect(p);
try operand.lvalConversion(p);
if (!operand.ty.isInt() and !operand.ty.isFloat())
try p.errStr(.invalid_argument_un, tok, try p.typeStr(operand.ty));
try operand.usualUnaryConversion(p, tok);
return operand;
},
.minus => {
p.tok_i += 1;
var operand = try p.castExpr();
try operand.expect(p);
try operand.lvalConversion(p);
if (!operand.ty.isInt() and !operand.ty.isFloat())
try p.errStr(.invalid_argument_un, tok, try p.typeStr(operand.ty));
try operand.usualUnaryConversion(p, tok);
if (operand.val.isArithmetic(p.comp)) {
_ = try operand.val.sub(Value.zero, operand.val, operand.ty, p.comp);
} else {
operand.val = .{};
}
try operand.un(p, .negate_expr, tok);
return operand;
},
.plus_plus => {
p.tok_i += 1;
var operand = try p.castExpr();
try operand.expect(p);
if (!operand.ty.isScalar())
try p.errStr(.invalid_argument_un, tok, try p.typeStr(operand.ty));
if (operand.ty.isComplex())
try p.errStr(.complex_prefix_postfix_op, p.tok_i, try p.typeStr(operand.ty));
if (!p.tmpTree().isLval(operand.node) or operand.ty.isConst()) {
try p.errTok(.not_assignable, tok);
return error.ParsingFailed;
}
try operand.usualUnaryConversion(p, tok);
if (operand.val.is(.int, p.comp) or operand.val.is(.int, p.comp)) {
if (try operand.val.add(operand.val, Value.one, operand.ty, p.comp))
try p.errOverflow(tok, operand);
} else {
operand.val = .{};
}
try operand.un(p, .pre_inc_expr, tok);
return operand;
},
.minus_minus => {
p.tok_i += 1;
var operand = try p.castExpr();
try operand.expect(p);
if (!operand.ty.isScalar())
try p.errStr(.invalid_argument_un, tok, try p.typeStr(operand.ty));
if (operand.ty.isComplex())
try p.errStr(.complex_prefix_postfix_op, p.tok_i, try p.typeStr(operand.ty));
if (!p.tmpTree().isLval(operand.node) or operand.ty.isConst()) {
try p.errTok(.not_assignable, tok);
return error.ParsingFailed;
}
try operand.usualUnaryConversion(p, tok);
if (operand.val.is(.int, p.comp) or operand.val.is(.int, p.comp)) {
if (try operand.val.sub(operand.val, Value.one, operand.ty, p.comp))
try p.errOverflow(tok, operand);
} else {
operand.val = .{};
}
try operand.un(p, .pre_dec_expr, tok);
return operand;
},
.tilde => {
p.tok_i += 1;
var operand = try p.castExpr();
try operand.expect(p);
try operand.lvalConversion(p);
try operand.usualUnaryConversion(p, tok);
if (operand.ty.isInt()) {
if (operand.val.is(.int, p.comp)) {
operand.val = try operand.val.bitNot(operand.ty, p.comp);
}
} else if (operand.ty.isComplex()) {
try p.errStr(.complex_conj, tok, try p.typeStr(operand.ty));
if (operand.val.is(.complex, p.comp)) {
operand.val = try operand.val.complexConj(operand.ty, p.comp);
}
} else {
try p.errStr(.invalid_argument_un, tok, try p.typeStr(operand.ty));
operand.val = .{};
}
try operand.un(p, .bit_not_expr, tok);
return operand;
},
.bang => {
p.tok_i += 1;
var operand = try p.castExpr();
try operand.expect(p);
try operand.lvalConversion(p);
if (!operand.ty.isScalar())
try p.errStr(.invalid_argument_un, tok, try p.typeStr(operand.ty));
try operand.usualUnaryConversion(p, tok);
if (operand.val.is(.int, p.comp)) {
operand.val = Value.fromBool(!operand.val.toBool(p.comp));
} else if (operand.val.opt_ref == .null) {
operand.val = Value.one;
} else {
if (operand.ty.isDecayed()) {
operand.val = Value.zero;
} else {
operand.val = .{};
}
}
operand.ty = .{ .specifier = .int };
try operand.un(p, .bool_not_expr, tok);
return operand;
},
.keyword_sizeof => {
p.tok_i += 1;
const expected_paren = p.tok_i;
var res = Result{};
if (try p.typeName()) |ty| {
res.ty = ty;
try p.errTok(.expected_parens_around_typename, expected_paren);
} else if (p.eatToken(.l_paren)) |l_paren| {
if (try p.typeName()) |ty| {
res.ty = ty;
try p.expectClosing(l_paren, .r_paren);
} else {
p.tok_i = expected_paren;
res = try p.parseNoEval(unExpr);
}
} else {
res = try p.parseNoEval(unExpr);
}
if (res.ty.is(.void)) {
try p.errStr(.pointer_arith_void, tok, "sizeof");
} else if (res.ty.isDecayed()) {
const array_ty = res.ty.originalTypeOfDecayedArray();
const err_str = try p.typePairStrExtra(res.ty, " instead of ", array_ty);
try p.errStr(.sizeof_array_arg, tok, err_str);
}
if (res.ty.sizeof(p.comp)) |size| {
if (size == 0) {
try p.errTok(.sizeof_returns_zero, tok);
}
res.val = try Value.int(size, p.comp);
res.ty = p.comp.types.size;
} else {
res.val = .{};
if (res.ty.hasIncompleteSize()) {
try p.errStr(.invalid_sizeof, expected_paren - 1, try p.typeStr(res.ty));
res.ty = Type.invalid;
} else {
res.ty = p.comp.types.size;
}
}
try res.un(p, .sizeof_expr, tok);
return res;
},
.keyword_alignof,
.keyword_alignof1,
.keyword_alignof2,
.keyword_c23_alignof,
=> {
p.tok_i += 1;
const expected_paren = p.tok_i;
var res = Result{};
if (try p.typeName()) |ty| {
res.ty = ty;
try p.errTok(.expected_parens_around_typename, expected_paren);
} else if (p.eatToken(.l_paren)) |l_paren| {
if (try p.typeName()) |ty| {
res.ty = ty;
try p.expectClosing(l_paren, .r_paren);
} else {
p.tok_i = expected_paren;
res = try p.parseNoEval(unExpr);
try p.errTok(.alignof_expr, expected_paren);
}
} else {
res = try p.parseNoEval(unExpr);
try p.errTok(.alignof_expr, expected_paren);
}
if (res.ty.is(.void)) {
try p.errStr(.pointer_arith_void, tok, "alignof");
}
if (res.ty.alignable()) {
res.val = try Value.int(res.ty.alignof(p.comp), p.comp);
res.ty = p.comp.types.size;
} else {
try p.errStr(.invalid_alignof, expected_paren, try p.typeStr(res.ty));
res.ty = Type.invalid;
}
try res.un(p, .alignof_expr, tok);
return res;
},
.keyword_extension => {
p.tok_i += 1;
const saved_extension = p.extension_suppressed;
defer p.extension_suppressed = saved_extension;
p.extension_suppressed = true;
var child = try p.castExpr();
try child.expect(p);
return child;
},
.keyword_imag1, .keyword_imag2 => {
const imag_tok = p.tok_i;
p.tok_i += 1;
var operand = try p.castExpr();
try operand.expect(p);
try operand.lvalConversion(p);
if (operand.ty.is(.invalid)) return Result.invalid;
if (!operand.ty.isInt() and !operand.ty.isFloat()) {
try p.errStr(.invalid_imag, imag_tok, try p.typeStr(operand.ty));
}
if (operand.ty.isComplex()) {
operand.val = try operand.val.imaginaryPart(p.comp);
} else if (operand.ty.isReal()) {
switch (p.comp.langopts.emulate) {
.msvc => {}, // Doesn't support `_Complex` or `__imag` in the first place
.gcc => operand.val = Value.zero,
.clang => {
if (operand.val.is(.int, p.comp) or operand.val.is(.float, p.comp)) {
operand.val = Value.zero;
} else {
operand.val = .{};
}
},
}
}
// convert _Complex T to T
operand.ty = operand.ty.makeReal();
try operand.un(p, .imag_expr, tok);
return operand;
},
.keyword_real1, .keyword_real2 => {
const real_tok = p.tok_i;
p.tok_i += 1;
var operand = try p.castExpr();
try operand.expect(p);
try operand.lvalConversion(p);
if (operand.ty.is(.invalid)) return Result.invalid;
if (!operand.ty.isInt() and !operand.ty.isFloat()) {
try p.errStr(.invalid_real, real_tok, try p.typeStr(operand.ty));
}
// convert _Complex T to T
operand.ty = operand.ty.makeReal();
operand.val = try operand.val.realPart(p.comp);
try operand.un(p, .real_expr, tok);
return operand;
},
else => {
var lhs = try p.compoundLiteral();
if (lhs.empty(p)) {
lhs = try p.primaryExpr();
if (lhs.empty(p)) return lhs;
}
while (true) {
const suffix = try p.suffixExpr(lhs);
if (suffix.empty(p)) break;
lhs = suffix;
}
return lhs;
},
}
}
/// compoundLiteral
/// : '(' storageClassSpec* type_name ')' '{' initializer_list '}'
/// | '(' storageClassSpec* type_name ')' '{' initializer_list ',' '}'
fn compoundLiteral(p: *Parser) Error!Result {
const l_paren = p.eatToken(.l_paren) orelse return Result{};
var d: DeclSpec = .{ .ty = .{ .specifier = undefined } };
const any = if (p.comp.langopts.standard.atLeast(.c23))
try p.storageClassSpec(&d)
else
false;
const tag: Tree.Tag = switch (d.storage_class) {
.static => if (d.thread_local != null)
.static_thread_local_compound_literal_expr
else
.static_compound_literal_expr,
.register, .none => if (d.thread_local != null)
.thread_local_compound_literal_expr
else
.compound_literal_expr,
.auto, .@"extern", .typedef => |tok| blk: {
try p.errStr(.invalid_compound_literal_storage_class, tok, @tagName(d.storage_class));
d.storage_class = .none;
break :blk if (d.thread_local != null)
.thread_local_compound_literal_expr
else
.compound_literal_expr;
},
};
var ty = (try p.typeName()) orelse {
p.tok_i = l_paren;
if (any) {
try p.err(.expected_type);
return error.ParsingFailed;
}
return Result{};
};
if (d.storage_class == .register) ty.qual.register = true;
try p.expectClosing(l_paren, .r_paren);
if (ty.isFunc()) {
try p.err(.func_init);
} else if (ty.is(.variable_len_array)) {
try p.err(.vla_init);
} else if (ty.hasIncompleteSize() and !ty.is(.incomplete_array)) {
try p.errStr(.variable_incomplete_ty, p.tok_i, try p.typeStr(ty));
return error.ParsingFailed;
}
var init_list_expr = try p.initializer(ty);
if (d.constexpr) |_| {
// TODO error if not constexpr
}
try init_list_expr.un(p, tag, l_paren);
return init_list_expr;
}
/// suffixExpr
/// : '[' expr ']'
/// | '(' argumentExprList? ')'
/// | '.' IDENTIFIER
/// | '->' IDENTIFIER
/// | '++'
/// | '--'
/// argumentExprList : assignExpr (',' assignExpr)*
fn suffixExpr(p: *Parser, lhs: Result) Error!Result {
assert(!lhs.empty(p));
switch (p.tok_ids[p.tok_i]) {
.l_paren => return p.callExpr(lhs),
.plus_plus => {
defer p.tok_i += 1;
var operand = lhs;
if (!operand.ty.isScalar())
try p.errStr(.invalid_argument_un, p.tok_i, try p.typeStr(operand.ty));
if (operand.ty.isComplex())
try p.errStr(.complex_prefix_postfix_op, p.tok_i, try p.typeStr(operand.ty));
if (!p.tmpTree().isLval(operand.node) or operand.ty.isConst()) {
try p.err(.not_assignable);
return error.ParsingFailed;
}
try operand.usualUnaryConversion(p, p.tok_i);
try operand.un(p, .post_inc_expr, p.tok_i);
return operand;
},
.minus_minus => {
defer p.tok_i += 1;
var operand = lhs;
if (!operand.ty.isScalar())
try p.errStr(.invalid_argument_un, p.tok_i, try p.typeStr(operand.ty));
if (operand.ty.isComplex())
try p.errStr(.complex_prefix_postfix_op, p.tok_i, try p.typeStr(operand.ty));
if (!p.tmpTree().isLval(operand.node) or operand.ty.isConst()) {
try p.err(.not_assignable);
return error.ParsingFailed;
}
try operand.usualUnaryConversion(p, p.tok_i);
try operand.un(p, .post_dec_expr, p.tok_i);
return operand;
},
.l_bracket => {
const l_bracket = p.tok_i;
p.tok_i += 1;
var index = try p.expr();
try index.expect(p);
try p.expectClosing(l_bracket, .r_bracket);
const array_before_conversion = lhs;
const index_before_conversion = index;
var ptr = lhs;
try ptr.lvalConversion(p);
try index.lvalConversion(p);
if (ptr.ty.isPtr()) {
ptr.ty = ptr.ty.elemType();
if (index.ty.isInt()) {
try p.checkArrayBounds(index_before_conversion, array_before_conversion, l_bracket);
} else {
try p.errTok(.invalid_index, l_bracket);
}
} else if (index.ty.isPtr()) {
index.ty = index.ty.elemType();
if (ptr.ty.isInt()) {
try p.checkArrayBounds(array_before_conversion, index_before_conversion, l_bracket);
} else {
try p.errTok(.invalid_index, l_bracket);
}
std.mem.swap(Result, &ptr, &index);
} else {
try p.errTok(.invalid_subscript, l_bracket);
}
try ptr.saveValue(p);
try index.saveValue(p);
try ptr.bin(p, .array_access_expr, index, l_bracket);
return ptr;
},
.period => {
p.tok_i += 1;
const name = try p.expectIdentifier();
return p.fieldAccess(lhs, name, false);
},
.arrow => {
p.tok_i += 1;
const name = try p.expectIdentifier();
if (lhs.ty.isArray()) {
var copy = lhs;
copy.ty.decayArray();
try copy.implicitCast(p, .array_to_pointer);
return p.fieldAccess(copy, name, true);
}
return p.fieldAccess(lhs, name, true);
},
else => return Result{},
}
}
fn fieldAccess(
p: *Parser,
lhs: Result,
field_name_tok: TokenIndex,
is_arrow: bool,
) !Result {
const expr_ty = lhs.ty;
const is_ptr = expr_ty.isPtr();
const expr_base_ty = if (is_ptr) expr_ty.elemType() else expr_ty;
const record_ty = expr_base_ty.getRecord() orelse {
try p.errStr(.expected_record_ty, field_name_tok, try p.typeStr(expr_ty));
return error.ParsingFailed;
};
if (record_ty.isIncomplete()) {
try p.errStr(.deref_incomplete_ty_ptr, field_name_tok - 2, try p.typeStr(expr_base_ty));
return error.ParsingFailed;
}
if (is_arrow and !is_ptr) try p.errStr(.member_expr_not_ptr, field_name_tok, try p.typeStr(expr_ty));
if (!is_arrow and is_ptr) try p.errStr(.member_expr_ptr, field_name_tok, try p.typeStr(expr_ty));
const field_name = try StrInt.intern(p.comp, p.tokSlice(field_name_tok));
try p.validateFieldAccess(record_ty, expr_ty, field_name_tok, field_name);
var discard: u64 = 0;
return p.fieldAccessExtra(lhs.node, record_ty, field_name, is_arrow, &discard);
}
fn validateFieldAccess(p: *Parser, record_ty: *const Type.Record, expr_ty: Type, field_name_tok: TokenIndex, field_name: StringId) Error!void {
if (record_ty.hasField(field_name)) return;
p.strings.items.len = 0;
try p.strings.writer().print("'{s}' in '", .{p.tokSlice(field_name_tok)});
const mapper = p.comp.string_interner.getSlowTypeMapper();
try expr_ty.print(mapper, p.comp.langopts, p.strings.writer());
try p.strings.append('\'');
const duped = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items);
try p.errStr(.no_such_member, field_name_tok, duped);
return error.ParsingFailed;
}
fn fieldAccessExtra(p: *Parser, lhs: NodeIndex, record_ty: *const Type.Record, field_name: StringId, is_arrow: bool, offset_bits: *u64) Error!Result {
for (record_ty.fields, 0..) |f, i| {
if (f.isAnonymousRecord()) {
if (!f.ty.hasField(field_name)) continue;
const inner = try p.addNode(.{
.tag = if (is_arrow) .member_access_ptr_expr else .member_access_expr,
.ty = f.ty,
.data = .{ .member = .{ .lhs = lhs, .index = @intCast(i) } },
});
const ret = p.fieldAccessExtra(inner, f.ty.getRecord().?, field_name, false, offset_bits);
offset_bits.* = f.layout.offset_bits;
return ret;
}
if (field_name == f.name) {
offset_bits.* = f.layout.offset_bits;
return Result{
.ty = f.ty,
.node = try p.addNode(.{
.tag = if (is_arrow) .member_access_ptr_expr else .member_access_expr,
.ty = f.ty,
.data = .{ .member = .{ .lhs = lhs, .index = @intCast(i) } },
}),
};
}
}
// We already checked that this container has a field by the name.
unreachable;
}
fn checkVaStartArg(p: *Parser, builtin_tok: TokenIndex, first_after: TokenIndex, param_tok: TokenIndex, arg: *Result, idx: u32) !void {
assert(idx != 0);
if (idx > 1) {
try p.errTok(.closing_paren, first_after);
return error.ParsingFailed;
}
var func_ty = p.func.ty orelse {
try p.errTok(.va_start_not_in_func, builtin_tok);
return;
};
const func_params = func_ty.params();
if (func_ty.specifier != .var_args_func or func_params.len == 0) {
return p.errTok(.va_start_fixed_args, builtin_tok);
}
const last_param_name = func_params[func_params.len - 1].name;
const decl_ref = p.getNode(arg.node, .decl_ref_expr);
if (decl_ref == null or last_param_name != try StrInt.intern(p.comp, p.tokSlice(p.nodes.items(.data)[@intFromEnum(decl_ref.?)].decl_ref))) {
try p.errTok(.va_start_not_last_param, param_tok);
}
}
fn checkArithOverflowArg(p: *Parser, builtin_tok: TokenIndex, first_after: TokenIndex, param_tok: TokenIndex, arg: *Result, idx: u32) !void {
_ = builtin_tok;
_ = first_after;
if (idx <= 1) {
if (!arg.ty.isInt()) {
return p.errStr(.overflow_builtin_requires_int, param_tok, try p.typeStr(arg.ty));
}
} else if (idx == 2) {
if (!arg.ty.isPtr()) return p.errStr(.overflow_result_requires_ptr, param_tok, try p.typeStr(arg.ty));
const child = arg.ty.elemType();
if (!child.isInt() or child.is(.bool) or child.is(.@"enum") or child.qual.@"const") return p.errStr(.overflow_result_requires_ptr, param_tok, try p.typeStr(arg.ty));
}
}
fn checkComplexArg(p: *Parser, builtin_tok: TokenIndex, first_after: TokenIndex, param_tok: TokenIndex, arg: *Result, idx: u32) !void {
_ = builtin_tok;
_ = first_after;
if (idx <= 1 and !arg.ty.isFloat()) {
try p.errStr(.not_floating_type, param_tok, try p.typeStr(arg.ty));
} else if (idx == 1) {
const prev_idx = p.list_buf.items[p.list_buf.items.len - 1];
const prev_ty = p.nodes.items(.ty)[@intFromEnum(prev_idx)];
if (!prev_ty.eql(arg.ty, p.comp, false)) {
try p.errStr(.argument_types_differ, param_tok, try p.typePairStrExtra(prev_ty, " vs ", arg.ty));
}
}
}
fn callExpr(p: *Parser, lhs: Result) Error!Result {
const l_paren = p.tok_i;
p.tok_i += 1;
const ty = lhs.ty.isCallable() orelse {
try p.errStr(.not_callable, l_paren, try p.typeStr(lhs.ty));
return error.ParsingFailed;
};
const params = ty.params();
var func = lhs;
try func.lvalConversion(p);
const list_buf_top = p.list_buf.items.len;
defer p.list_buf.items.len = list_buf_top;
try p.list_buf.append(func.node);
var arg_count: u32 = 0;
var first_after = l_paren;
const call_expr = CallExpr.init(p, lhs.node, func.node);
while (p.eatToken(.r_paren) == null) {
const param_tok = p.tok_i;
if (arg_count == params.len) first_after = p.tok_i;
var arg = try p.assignExpr();
try arg.expect(p);
if (call_expr.shouldPerformLvalConversion(arg_count)) {
try arg.lvalConversion(p);
}
if (arg.ty.hasIncompleteSize() and !arg.ty.is(.void)) return error.ParsingFailed;
if (arg_count >= params.len) {
if (call_expr.shouldPromoteVarArg(arg_count)) {
if (arg.ty.isInt()) try arg.intCast(p, arg.ty.integerPromotion(p.comp), param_tok);
if (arg.ty.is(.float)) try arg.floatCast(p, .{ .specifier = .double });
}
try call_expr.checkVarArg(p, first_after, param_tok, &arg, arg_count);
try arg.saveValue(p);
try p.list_buf.append(arg.node);
arg_count += 1;
_ = p.eatToken(.comma) orelse {
try p.expectClosing(l_paren, .r_paren);
break;
};
continue;
}
const p_ty = params[arg_count].ty;
if (p_ty.specifier == .static_array) {
const arg_array_len: u64 = arg.ty.arrayLen() orelse std.math.maxInt(u64);
const param_array_len: u64 = p_ty.arrayLen().?;
if (arg_array_len < param_array_len) {
const extra = Diagnostics.Message.Extra{ .arguments = .{
.expected = @intCast(arg_array_len),
.actual = @intCast(param_array_len),
} };
try p.errExtra(.array_argument_too_small, param_tok, extra);
try p.errTok(.callee_with_static_array, params[arg_count].name_tok);
}
if (arg.val.isZero(p.comp)) {
try p.errTok(.non_null_argument, param_tok);
try p.errTok(.callee_with_static_array, params[arg_count].name_tok);
}
}
if (call_expr.shouldCoerceArg(arg_count)) {
try arg.coerce(p, p_ty, param_tok, .{ .arg = params[arg_count].name_tok });
}
try arg.saveValue(p);
try p.list_buf.append(arg.node);
arg_count += 1;
_ = p.eatToken(.comma) orelse {
try p.expectClosing(l_paren, .r_paren);
break;
};
}
const actual: u32 = @intCast(arg_count);
const extra = Diagnostics.Message.Extra{ .arguments = .{
.expected = @intCast(params.len),
.actual = actual,
} };
if (call_expr.paramCountOverride()) |expected| {
if (expected != actual) {
try p.errExtra(.expected_arguments, first_after, .{ .arguments = .{ .expected = expected, .actual = actual } });
}
} else if (ty.is(.func) and params.len != arg_count) {
try p.errExtra(.expected_arguments, first_after, extra);
} else if (ty.is(.old_style_func) and params.len != arg_count) {
if (params.len == 0)
try p.errTok(.passing_args_to_kr, first_after)
else
try p.errExtra(.expected_arguments_old, first_after, extra);
} else if (ty.is(.var_args_func) and arg_count < params.len) {
try p.errExtra(.expected_at_least_arguments, first_after, extra);
}
return call_expr.finish(p, ty, list_buf_top, arg_count);
}
fn checkArrayBounds(p: *Parser, index: Result, array: Result, tok: TokenIndex) !void {
if (index.val.opt_ref == .none) return;
const array_len = array.ty.arrayLen() orelse return;
if (array_len == 0) return;
if (array_len == 1) {
if (p.getNode(array.node, .member_access_expr) orelse p.getNode(array.node, .member_access_ptr_expr)) |node| {
const data = p.nodes.items(.data)[@intFromEnum(node)];
var lhs = p.nodes.items(.ty)[@intFromEnum(data.member.lhs)];
if (lhs.get(.pointer)) |ptr| {
lhs = ptr.data.sub_type.*;
}
if (lhs.is(.@"struct")) {
const record = lhs.getRecord().?;
if (data.member.index + 1 == record.fields.len) {
if (!index.val.isZero(p.comp)) {
try p.errStr(.old_style_flexible_struct, tok, try index.str(p));
}
return;
}
}
}
}
const index_int = index.val.toInt(u64, p.comp) orelse std.math.maxInt(u64);
if (index.ty.isUnsignedInt(p.comp)) {
if (index_int >= array_len) {
try p.errStr(.array_after, tok, try index.str(p));
}
} else {
if (index.val.compare(.lt, Value.zero, p.comp)) {
try p.errStr(.array_before, tok, try index.str(p));
} else if (index_int >= array_len) {
try p.errStr(.array_after, tok, try index.str(p));
}
}
}
/// primaryExpr
/// : IDENTIFIER
/// | keyword_true
/// | keyword_false
/// | keyword_nullptr
/// | INTEGER_LITERAL
/// | FLOAT_LITERAL
/// | IMAGINARY_LITERAL
/// | CHAR_LITERAL
/// | STRING_LITERAL
/// | '(' expr ')'
/// | genericSelection
fn primaryExpr(p: *Parser) Error!Result {
if (p.eatToken(.l_paren)) |l_paren| {
var e = try p.expr();
try e.expect(p);
try p.expectClosing(l_paren, .r_paren);
try e.un(p, .paren_expr, l_paren);
return e;
}
switch (p.tok_ids[p.tok_i]) {
.identifier, .extended_identifier => {
const name_tok = try p.expectIdentifier();
const name = p.tokSlice(name_tok);
const interned_name = try StrInt.intern(p.comp, name);
if (interned_name == p.auto_type_decl_name) {
try p.errStr(.auto_type_self_initialized, name_tok, name);
return error.ParsingFailed;
}
if (p.syms.findSymbol(interned_name)) |sym| {
try p.checkDeprecatedUnavailable(sym.ty, name_tok, sym.tok);
if (sym.kind == .constexpr) {
return Result{
.val = sym.val,
.ty = sym.ty,
.node = try p.addNode(.{
.tag = .decl_ref_expr,
.ty = sym.ty,
.data = .{ .decl_ref = name_tok },
.loc = @enumFromInt(name_tok),
}),
};
}
if (sym.val.is(.int, p.comp)) {
switch (p.const_decl_folding) {
.gnu_folding_extension => try p.errTok(.const_decl_folded, name_tok),
.gnu_vla_folding_extension => try p.errTok(.const_decl_folded_vla, name_tok),
else => {},
}
}
return Result{
.val = if (p.const_decl_folding == .no_const_decl_folding and sym.kind != .enumeration) Value{} else sym.val,
.ty = sym.ty,
.node = try p.addNode(.{
.tag = if (sym.kind == .enumeration) .enumeration_ref else .decl_ref_expr,
.ty = sym.ty,
.data = .{ .decl_ref = name_tok },
.loc = @enumFromInt(name_tok),
}),
};
}
if (try p.comp.builtins.getOrCreate(p.comp, name, p.arena)) |some| {
for (p.tok_ids[p.tok_i..]) |id| switch (id) {
.r_paren => {}, // closing grouped expr
.l_paren => break, // beginning of a call
else => {
try p.errTok(.builtin_must_be_called, name_tok);
return error.ParsingFailed;
},
};
if (some.builtin.properties.header != .none) {
try p.errStr(.implicit_builtin, name_tok, name);
try p.errExtra(.implicit_builtin_header_note, name_tok, .{ .builtin_with_header = .{
.builtin = some.builtin.tag,
.header = some.builtin.properties.header,
} });
}
return Result{
.ty = some.ty,
.node = try p.addNode(.{
.tag = .builtin_call_expr_one,
.ty = some.ty,
.data = .{ .decl = .{ .name = name_tok, .node = .none } },
.loc = @enumFromInt(name_tok),
}),
};
}
if (p.tok_ids[p.tok_i] == .l_paren and !p.comp.langopts.standard.atLeast(.c23)) {
// allow implicitly declaring functions before C99 like `puts("foo")`
if (mem.startsWith(u8, name, "__builtin_"))
try p.errStr(.unknown_builtin, name_tok, name)
else
try p.errStr(.implicit_func_decl, name_tok, name);
const func_ty = try p.arena.create(Type.Func);
func_ty.* = .{ .return_type = .{ .specifier = .int }, .params = &.{} };
const ty: Type = .{ .specifier = .old_style_func, .data = .{ .func = func_ty } };
const node = try p.addNode(.{
.ty = ty,
.tag = .fn_proto,
.data = .{ .decl = .{ .name = name_tok } },
.loc = @enumFromInt(name_tok),
});
try p.decl_buf.append(node);
try p.syms.declareSymbol(p, interned_name, ty, name_tok, node);
return Result{
.ty = ty,
.node = try p.addNode(.{
.tag = .decl_ref_expr,
.ty = ty,
.data = .{ .decl_ref = name_tok },
.loc = @enumFromInt(name_tok),
}),
};
}
try p.errStr(.undeclared_identifier, name_tok, p.tokSlice(name_tok));
return error.ParsingFailed;
},
.keyword_true, .keyword_false => |id| {
const tok_i = p.tok_i;
p.tok_i += 1;
const res = Result{
.val = Value.fromBool(id == .keyword_true),
.ty = .{ .specifier = .bool },
.node = try p.addNode(.{ .tag = .bool_literal, .ty = .{ .specifier = .bool }, .data = undefined, .loc = @enumFromInt(tok_i) }),
};
std.debug.assert(!p.in_macro); // Should have been replaced with .one / .zero
try p.value_map.put(res.node, res.val);
return res;
},
.keyword_nullptr => {
defer p.tok_i += 1;
try p.errStr(.pre_c23_compat, p.tok_i, "'nullptr'");
return Result{
.val = Value.null,
.ty = .{ .specifier = .nullptr_t },
.node = try p.addNode(.{
.tag = .nullptr_literal,
.ty = .{ .specifier = .nullptr_t },
.data = undefined,
.loc = @enumFromInt(p.tok_i),
}),
};
},
.macro_func, .macro_function => {
defer p.tok_i += 1;
var ty: Type = undefined;
var tok = p.tok_i;
if (p.func.ident) |some| {
ty = some.ty;
tok = p.nodes.items(.data)[@intFromEnum(some.node)].decl.name;
} else if (p.func.ty) |_| {
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
try p.strings.appendSlice(p.tokSlice(p.func.name));
try p.strings.append(0);
const predef = try p.makePredefinedIdentifier(strings_top);
ty = predef.ty;
p.func.ident = predef;
} else {
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
try p.strings.append(0);
const predef = try p.makePredefinedIdentifier(strings_top);
ty = predef.ty;
p.func.ident = predef;
try p.decl_buf.append(predef.node);
}
if (p.func.ty == null) try p.err(.predefined_top_level);
return Result{
.ty = ty,
.node = try p.addNode(.{
.tag = .decl_ref_expr,
.ty = ty,
.data = .{ .decl_ref = tok },
.loc = @enumFromInt(tok),
}),
};
},
.macro_pretty_func => {
defer p.tok_i += 1;
var ty: Type = undefined;
if (p.func.pretty_ident) |some| {
ty = some.ty;
} else if (p.func.ty) |func_ty| {
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
const mapper = p.comp.string_interner.getSlowTypeMapper();
try Type.printNamed(func_ty, p.tokSlice(p.func.name), mapper, p.comp.langopts, p.strings.writer());
try p.strings.append(0);
const predef = try p.makePredefinedIdentifier(strings_top);
ty = predef.ty;
p.func.pretty_ident = predef;
} else {
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
try p.strings.appendSlice("top level\x00");
const predef = try p.makePredefinedIdentifier(strings_top);
ty = predef.ty;
p.func.pretty_ident = predef;
try p.decl_buf.append(predef.node);
}
if (p.func.ty == null) try p.err(.predefined_top_level);
return Result{
.ty = ty,
.node = try p.addNode(.{
.tag = .decl_ref_expr,
.ty = ty,
.data = .{ .decl_ref = p.tok_i },
.loc = @enumFromInt(p.tok_i),
}),
};
},
.string_literal,
.string_literal_utf_16,
.string_literal_utf_8,
.string_literal_utf_32,
.string_literal_wide,
.unterminated_string_literal,
=> return p.stringLiteral(),
.char_literal,
.char_literal_utf_8,
.char_literal_utf_16,
.char_literal_utf_32,
.char_literal_wide,
.empty_char_literal,
.unterminated_char_literal,
=> return p.charLiteral(),
.zero => {
defer p.tok_i += 1;
var res: Result = .{ .val = Value.zero, .ty = if (p.in_macro) p.comp.types.intmax else Type.int };
res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(p.tok_i) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
},
.one => {
defer p.tok_i += 1;
var res: Result = .{ .val = Value.one, .ty = if (p.in_macro) p.comp.types.intmax else Type.int };
res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(p.tok_i) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
},
.pp_num => return p.ppNum(),
.embed_byte => {
assert(!p.in_macro);
const loc = p.pp.tokens.items(.loc)[p.tok_i];
defer p.tok_i += 1;
const buf = p.comp.getSource(.generated).buf[loc.byte_offset..];
var byte: u8 = buf[0] - '0';
for (buf[1..]) |c| {
if (!std.ascii.isDigit(c)) break;
byte *= 10;
byte += c - '0';
}
var res: Result = .{ .val = try Value.int(byte, p.comp) };
res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(p.tok_i) });
try p.value_map.put(res.node, res.val);
return res;
},
.keyword_generic => return p.genericSelection(),
else => return Result{},
}
}
fn makePredefinedIdentifier(p: *Parser, strings_top: usize) !Result {
const end: u32 = @intCast(p.strings.items.len);
const elem_ty = .{ .specifier = .char, .qual = .{ .@"const" = true } };
const arr_ty = try p.arena.create(Type.Array);
arr_ty.* = .{ .elem = elem_ty, .len = end - strings_top };
const ty: Type = .{ .specifier = .array, .data = .{ .array = arr_ty } };
const slice = p.strings.items[strings_top..];
const val = try Value.intern(p.comp, .{ .bytes = slice });
const str_lit = try p.addNode(.{ .tag = .string_literal_expr, .ty = ty, .data = undefined, .loc = @enumFromInt(p.tok_i) });
if (!p.in_macro) try p.value_map.put(str_lit, val);
return Result{ .ty = ty, .node = try p.addNode(.{
.tag = .implicit_static_var,
.ty = ty,
.data = .{ .decl = .{ .name = p.tok_i, .node = str_lit } },
.loc = @enumFromInt(p.tok_i),
}) };
}
fn stringLiteral(p: *Parser) Error!Result {
const string_start = p.tok_i;
var string_end = p.tok_i;
var string_kind: text_literal.Kind = .char;
while (text_literal.Kind.classify(p.tok_ids[string_end], .string_literal)) |next| : (string_end += 1) {
string_kind = string_kind.concat(next) catch {
try p.errTok(.unsupported_str_cat, string_end);
while (p.tok_ids[p.tok_i].isStringLiteral()) : (p.tok_i += 1) {}
return error.ParsingFailed;
};
if (string_kind == .unterminated) {
try p.errTok(.unterminated_string_literal_error, string_end);
p.tok_i = string_end + 1;
return error.ParsingFailed;
}
}
const count = string_end - p.tok_i;
assert(count > 0);
const char_width = string_kind.charUnitSize(p.comp);
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
const literal_start = mem.alignForward(usize, strings_top, @intFromEnum(char_width));
try p.strings.resize(literal_start);
while (p.tok_i < string_end) : (p.tok_i += 1) {
const this_kind = text_literal.Kind.classify(p.tok_ids[p.tok_i], .string_literal).?;
const slice = this_kind.contentSlice(p.tokSlice(p.tok_i));
var char_literal_parser = text_literal.Parser.init(slice, this_kind, 0x10ffff, p.comp);
try p.strings.ensureUnusedCapacity((slice.len + 1) * @intFromEnum(char_width)); // +1 for null terminator
while (char_literal_parser.next()) |item| switch (item) {
.value => |v| {
switch (char_width) {
.@"1" => p.strings.appendAssumeCapacity(@intCast(v)),
.@"2" => {
const word: u16 = @intCast(v);
p.strings.appendSliceAssumeCapacity(mem.asBytes(&word));
},
.@"4" => p.strings.appendSliceAssumeCapacity(mem.asBytes(&v)),
}
},
.codepoint => |c| {
switch (char_width) {
.@"1" => {
var buf: [4]u8 = undefined;
const written = std.unicode.utf8Encode(c, &buf) catch unreachable;
const encoded = buf[0..written];
p.strings.appendSliceAssumeCapacity(encoded);
},
.@"2" => {
var utf16_buf: [2]u16 = undefined;
var utf8_buf: [4]u8 = undefined;
const utf8_written = std.unicode.utf8Encode(c, &utf8_buf) catch unreachable;
const utf16_written = std.unicode.utf8ToUtf16Le(&utf16_buf, utf8_buf[0..utf8_written]) catch unreachable;
const bytes = std.mem.sliceAsBytes(utf16_buf[0..utf16_written]);
p.strings.appendSliceAssumeCapacity(bytes);
},
.@"4" => {
const val: u32 = c;
p.strings.appendSliceAssumeCapacity(mem.asBytes(&val));
},
}
},
.improperly_encoded => |bytes| {
if (count > 1) {
try p.errTok(.illegal_char_encoding_error, p.tok_i);
return error.ParsingFailed;
}
p.strings.appendSliceAssumeCapacity(bytes);
},
.utf8_text => |view| {
switch (char_width) {
.@"1" => p.strings.appendSliceAssumeCapacity(view.bytes),
.@"2" => {
const capacity_slice: []align(@alignOf(u16)) u8 = @alignCast(p.strings.allocatedSlice()[literal_start..]);
const dest_len = std.mem.alignBackward(usize, capacity_slice.len, 2);
const dest = std.mem.bytesAsSlice(u16, capacity_slice[0..dest_len]);
const words_written = std.unicode.utf8ToUtf16Le(dest, view.bytes) catch unreachable;
p.strings.resize(p.strings.items.len + words_written * 2) catch unreachable;
},
.@"4" => {
var it = view.iterator();
while (it.nextCodepoint()) |codepoint| {
const val: u32 = codepoint;
p.strings.appendSliceAssumeCapacity(mem.asBytes(&val));
}
},
}
},
};
for (char_literal_parser.errors()) |item| {
try p.errExtra(item.tag, p.tok_i, item.extra);
}
}
p.strings.appendNTimesAssumeCapacity(0, @intFromEnum(char_width));
const slice = p.strings.items[literal_start..];
// TODO this won't do anything if there is a cache hit
const interned_align = mem.alignForward(
usize,
p.comp.interner.strings.items.len,
string_kind.internalStorageAlignment(p.comp),
);
try p.comp.interner.strings.resize(p.gpa, interned_align);
const val = try Value.intern(p.comp, .{ .bytes = slice });
const arr_ty = try p.arena.create(Type.Array);
arr_ty.* = .{ .elem = string_kind.elementType(p.comp), .len = @divExact(slice.len, @intFromEnum(char_width)) };
var res: Result = .{
.ty = .{
.specifier = .array,
.data = .{ .array = arr_ty },
},
.val = val,
};
res.node = try p.addNode(.{ .tag = .string_literal_expr, .ty = res.ty, .data = undefined, .loc = @enumFromInt(string_start) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
}
fn charLiteral(p: *Parser) Error!Result {
defer p.tok_i += 1;
const tok_id = p.tok_ids[p.tok_i];
const char_kind = text_literal.Kind.classify(tok_id, .char_literal) orelse {
if (tok_id == .empty_char_literal) {
try p.err(.empty_char_literal_error);
} else if (tok_id == .unterminated_char_literal) {
try p.err(.unterminated_char_literal_error);
} else unreachable;
return .{
.ty = Type.int,
.val = Value.zero,
.node = try p.addNode(.{ .tag = .char_literal, .ty = Type.int, .data = undefined, .loc = @enumFromInt(p.tok_i) }),
};
};
if (char_kind == .utf_8) try p.err(.u8_char_lit);
var val: u32 = 0;
const slice = char_kind.contentSlice(p.tokSlice(p.tok_i));
var is_multichar = false;
if (slice.len == 1 and std.ascii.isASCII(slice[0])) {
// fast path: single unescaped ASCII char
val = slice[0];
} else {
const max_codepoint = char_kind.maxCodepoint(p.comp);
var char_literal_parser = text_literal.Parser.init(slice, char_kind, max_codepoint, p.comp);
const max_chars_expected = 4;
var stack_fallback = std.heap.stackFallback(max_chars_expected * @sizeOf(u32), p.comp.gpa);
var chars = std.ArrayList(u32).initCapacity(stack_fallback.get(), max_chars_expected) catch unreachable; // stack allocation already succeeded
defer chars.deinit();
while (char_literal_parser.next()) |item| switch (item) {
.value => |v| try chars.append(v),
.codepoint => |c| try chars.append(c),
.improperly_encoded => |s| {
try chars.ensureUnusedCapacity(s.len);
for (s) |c| chars.appendAssumeCapacity(c);
},
.utf8_text => |view| {
var it = view.iterator();
var max_codepoint_seen: u21 = 0;
try chars.ensureUnusedCapacity(view.bytes.len);
while (it.nextCodepoint()) |c| {
max_codepoint_seen = @max(max_codepoint_seen, c);
chars.appendAssumeCapacity(c);
}
if (max_codepoint_seen > max_codepoint) {
char_literal_parser.err(.char_too_large, .{ .none = {} });
}
},
};
is_multichar = chars.items.len > 1;
if (is_multichar) {
if (char_kind == .char and chars.items.len == 4) {
char_literal_parser.warn(.four_char_char_literal, .{ .none = {} });
} else if (char_kind == .char) {
char_literal_parser.warn(.multichar_literal_warning, .{ .none = {} });
} else {
const kind = switch (char_kind) {
.wide => "wide",
.utf_8, .utf_16, .utf_32 => "Unicode",
else => unreachable,
};
char_literal_parser.err(.invalid_multichar_literal, .{ .str = kind });
}
}
var multichar_overflow = false;
if (char_kind == .char and is_multichar) {
for (chars.items) |item| {
val, const overflowed = @shlWithOverflow(val, 8);
multichar_overflow = multichar_overflow or overflowed != 0;
val += @as(u8, @truncate(item));
}
} else if (chars.items.len > 0) {
val = chars.items[chars.items.len - 1];
}
if (multichar_overflow) {
char_literal_parser.err(.char_lit_too_wide, .{ .none = {} });
}
for (char_literal_parser.errors()) |item| {
try p.errExtra(item.tag, p.tok_i, item.extra);
}
}
const ty = char_kind.charLiteralType(p.comp);
// This is the type the literal will have if we're in a macro; macros always operate on intmax_t/uintmax_t values
const macro_ty = if (ty.isUnsignedInt(p.comp) or (char_kind == .char and p.comp.getCharSignedness() == .unsigned))
p.comp.types.intmax.makeIntegerUnsigned()
else
p.comp.types.intmax;
var value = try Value.int(val, p.comp);
// C99 6.4.4.4.10
// > If an integer character constant contains a single character or escape sequence,
// > its value is the one that results when an object with type char whose value is
// > that of the single character or escape sequence is converted to type int.
// This conversion only matters if `char` is signed and has a high-order bit of `1`
if (char_kind == .char and !is_multichar and val > 0x7F and p.comp.getCharSignedness() == .signed) {
_ = try value.intCast(.{ .specifier = .char }, p.comp);
}
const res = Result{
.ty = if (p.in_macro) macro_ty else ty,
.val = value,
.node = try p.addNode(.{ .tag = .char_literal, .ty = ty, .data = undefined, .loc = @enumFromInt(p.tok_i) }),
};
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
}
fn parseFloat(p: *Parser, buf: []const u8, suffix: NumberSuffix, tok_i: TokenIndex) !Result {
const ty = Type{ .specifier = switch (suffix) {
.None, .I => .double,
.F, .IF => .float,
.F16, .IF16 => .float16,
.L, .IL => .long_double,
.W, .IW => p.comp.float80Type().?.specifier,
.Q, .IQ, .F128, .IF128 => .float128,
else => unreachable,
} };
const val = try Value.intern(p.comp, key: {
try p.strings.ensureUnusedCapacity(buf.len);
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
for (buf) |c| {
if (c != '\'') p.strings.appendAssumeCapacity(c);
}
const float = std.fmt.parseFloat(f128, p.strings.items[strings_top..]) catch unreachable;
const bits = ty.bitSizeof(p.comp).?;
break :key switch (bits) {
16 => .{ .float = .{ .f16 = @floatCast(float) } },
32 => .{ .float = .{ .f32 = @floatCast(float) } },
64 => .{ .float = .{ .f64 = @floatCast(float) } },
80 => .{ .float = .{ .f80 = @floatCast(float) } },
128 => .{ .float = .{ .f128 = @floatCast(float) } },
else => unreachable,
};
});
var res = Result{
.ty = ty,
.node = try p.addNode(.{ .tag = .float_literal, .ty = ty, .data = undefined, .loc = @enumFromInt(tok_i) }),
.val = val,
};
if (suffix.isImaginary()) {
try p.err(.gnu_imaginary_constant);
res.ty = .{ .specifier = switch (suffix) {
.I => .complex_double,
.IF16 => .complex_float16,
.IF => .complex_float,
.IL => .complex_long_double,
.IW => p.comp.float80Type().?.makeComplex().specifier,
.IQ, .IF128 => .complex_float128,
else => unreachable,
} };
res.val = try Value.intern(p.comp, switch (res.ty.bitSizeof(p.comp).?) {
32 => .{ .complex = .{ .cf16 = .{ 0.0, val.toFloat(f16, p.comp) } } },
64 => .{ .complex = .{ .cf32 = .{ 0.0, val.toFloat(f32, p.comp) } } },
128 => .{ .complex = .{ .cf64 = .{ 0.0, val.toFloat(f64, p.comp) } } },
160 => .{ .complex = .{ .cf80 = .{ 0.0, val.toFloat(f80, p.comp) } } },
256 => .{ .complex = .{ .cf128 = .{ 0.0, val.toFloat(f128, p.comp) } } },
else => unreachable,
});
try res.un(p, .imaginary_literal, tok_i);
}
return res;
}
fn getIntegerPart(p: *Parser, buf: []const u8, prefix: NumberPrefix, tok_i: TokenIndex) ![]const u8 {
if (buf[0] == '.') return "";
if (!prefix.digitAllowed(buf[0])) {
switch (prefix) {
.binary => try p.errExtra(.invalid_binary_digit, tok_i, .{ .ascii = @intCast(buf[0]) }),
.octal => try p.errExtra(.invalid_octal_digit, tok_i, .{ .ascii = @intCast(buf[0]) }),
.hex => try p.errStr(.invalid_int_suffix, tok_i, buf),
.decimal => unreachable,
}
return error.ParsingFailed;
}
for (buf, 0..) |c, idx| {
if (idx == 0) continue;
switch (c) {
'.' => return buf[0..idx],
'p', 'P' => return if (prefix == .hex) buf[0..idx] else {
try p.errStr(.invalid_int_suffix, tok_i, buf[idx..]);
return error.ParsingFailed;
},
'e', 'E' => {
switch (prefix) {
.hex => continue,
.decimal => return buf[0..idx],
.binary => try p.errExtra(.invalid_binary_digit, tok_i, .{ .ascii = @intCast(c) }),
.octal => try p.errExtra(.invalid_octal_digit, tok_i, .{ .ascii = @intCast(c) }),
}
return error.ParsingFailed;
},
'0'...'9', 'a'...'d', 'A'...'D', 'f', 'F' => {
if (!prefix.digitAllowed(c)) {
switch (prefix) {
.binary => try p.errExtra(.invalid_binary_digit, tok_i, .{ .ascii = @intCast(c) }),
.octal => try p.errExtra(.invalid_octal_digit, tok_i, .{ .ascii = @intCast(c) }),
.decimal, .hex => try p.errStr(.invalid_int_suffix, tok_i, buf[idx..]),
}
return error.ParsingFailed;
}
},
'\'' => {},
else => return buf[0..idx],
}
}
return buf;
}
fn fixedSizeInt(p: *Parser, base: u8, buf: []const u8, suffix: NumberSuffix, tok_i: TokenIndex) !Result {
var val: u64 = 0;
var overflow = false;
for (buf) |c| {
const digit: u64 = switch (c) {
'0'...'9' => c - '0',
'A'...'Z' => c - 'A' + 10,
'a'...'z' => c - 'a' + 10,
'\'' => continue,
else => unreachable,
};
if (val != 0) {
const product, const overflowed = @mulWithOverflow(val, base);
if (overflowed != 0) {
overflow = true;
}
val = product;
}
const sum, const overflowed = @addWithOverflow(val, digit);
if (overflowed != 0) overflow = true;
val = sum;
}
var res: Result = .{ .val = try Value.int(val, p.comp) };
if (overflow) {
try p.errTok(.int_literal_too_big, tok_i);
res.ty = .{ .specifier = .ulong_long };
res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(tok_i) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
}
const interned_val = try Value.int(val, p.comp);
if (suffix.isSignedInteger()) {
const max_int = try Value.maxInt(p.comp.types.intmax, p.comp);
if (interned_val.compare(.gt, max_int, p.comp)) {
try p.errTok(.implicitly_unsigned_literal, tok_i);
}
}
const signed_specs = .{ .int, .long, .long_long };
const unsigned_specs = .{ .uint, .ulong, .ulong_long };
const signed_oct_hex_specs = .{ .int, .uint, .long, .ulong, .long_long, .ulong_long };
const specs: []const Type.Specifier = if (suffix.signedness() == .unsigned)
&unsigned_specs
else if (base == 10)
&signed_specs
else
&signed_oct_hex_specs;
const suffix_ty: Type = .{ .specifier = switch (suffix) {
.None, .I => .int,
.U, .IU => .uint,
.UL, .IUL => .ulong,
.ULL, .IULL => .ulong_long,
.L, .IL => .long,
.LL, .ILL => .long_long,
else => unreachable,
} };
for (specs) |spec| {
res.ty = Type{ .specifier = spec };
if (res.ty.compareIntegerRanks(suffix_ty, p.comp).compare(.lt)) continue;
const max_int = try Value.maxInt(res.ty, p.comp);
if (interned_val.compare(.lte, max_int, p.comp)) break;
} else {
res.ty = .{ .specifier = spec: {
if (p.comp.langopts.emulate == .gcc) {
if (target_util.hasInt128(p.comp.target)) {
break :spec .int128;
} else {
break :spec .long_long;
}
} else {
break :spec .ulong_long;
}
} };
}
res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(tok_i) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
}
fn parseInt(p: *Parser, prefix: NumberPrefix, buf: []const u8, suffix: NumberSuffix, tok_i: TokenIndex) !Result {
if (prefix == .binary) {
try p.errTok(.binary_integer_literal, tok_i);
}
const base = @intFromEnum(prefix);
var res = if (suffix.isBitInt())
try p.bitInt(base, buf, suffix, tok_i)
else
try p.fixedSizeInt(base, buf, suffix, tok_i);
if (suffix.isImaginary()) {
try p.errTok(.gnu_imaginary_constant, tok_i);
res.ty = res.ty.makeComplex();
res.val = .{};
try res.un(p, .imaginary_literal, tok_i);
}
return res;
}
fn bitInt(p: *Parser, base: u8, buf: []const u8, suffix: NumberSuffix, tok_i: TokenIndex) Error!Result {
try p.errStr(.pre_c23_compat, tok_i, "'_BitInt' suffix for literals");
try p.errTok(.bitint_suffix, tok_i);
var managed = try big.int.Managed.init(p.gpa);
defer managed.deinit();
{
try p.strings.ensureUnusedCapacity(buf.len);
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
for (buf) |c| {
if (c != '\'') p.strings.appendAssumeCapacity(c);
}
managed.setString(base, p.strings.items[strings_top..]) catch |e| switch (e) {
error.InvalidBase => unreachable, // `base` is one of 2, 8, 10, 16
error.InvalidCharacter => unreachable, // digits validated by Tokenizer
else => |er| return er,
};
}
const c = managed.toConst();
const bits_needed: std.math.IntFittingRange(0, Compilation.bit_int_max_bits) = blk: {
// Literal `0` requires at least 1 bit
const count = @max(1, c.bitCountTwosComp());
// The wb suffix results in a _BitInt that includes space for the sign bit even if the
// value of the constant is positive or was specified in hexadecimal or octal notation.
const sign_bits = @intFromBool(suffix.isSignedInteger());
const bits_needed = count + sign_bits;
break :blk @intCast(bits_needed);
};
var res: Result = .{
.val = try Value.intern(p.comp, .{ .int = .{ .big_int = c } }),
.ty = .{
.specifier = .bit_int,
.data = .{ .int = .{ .bits = bits_needed, .signedness = suffix.signedness() } },
},
};
res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(tok_i) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
}
fn getFracPart(p: *Parser, buf: []const u8, prefix: NumberPrefix, tok_i: TokenIndex) ![]const u8 {
if (buf.len == 0 or buf[0] != '.') return "";
assert(prefix != .octal);
if (prefix == .binary) {
try p.errStr(.invalid_int_suffix, tok_i, buf);
return error.ParsingFailed;
}
for (buf, 0..) |c, idx| {
if (idx == 0) continue;
if (c == '\'') continue;
if (!prefix.digitAllowed(c)) return buf[0..idx];
}
return buf;
}
fn getExponent(p: *Parser, buf: []const u8, prefix: NumberPrefix, tok_i: TokenIndex) ![]const u8 {
if (buf.len == 0) return "";
switch (buf[0]) {
'e', 'E' => assert(prefix == .decimal),
'p', 'P' => if (prefix != .hex) {
try p.errStr(.invalid_float_suffix, tok_i, buf);
return error.ParsingFailed;
},
else => return "",
}
const end = for (buf, 0..) |c, idx| {
if (idx == 0) continue;
if (idx == 1 and (c == '+' or c == '-')) continue;
switch (c) {
'0'...'9' => {},
'\'' => continue,
else => break idx,
}
} else buf.len;
const exponent = buf[0..end];
if (std.mem.indexOfAny(u8, exponent, "0123456789") == null) {
try p.errTok(.exponent_has_no_digits, tok_i);
return error.ParsingFailed;
}
return exponent;
}
/// Using an explicit `tok_i` parameter instead of `p.tok_i` makes it easier
/// to parse numbers in pragma handlers.
pub fn parseNumberToken(p: *Parser, tok_i: TokenIndex) !Result {
const buf = p.tokSlice(tok_i);
const prefix = NumberPrefix.fromString(buf);
const after_prefix = buf[prefix.stringLen()..];
const int_part = try p.getIntegerPart(after_prefix, prefix, tok_i);
const after_int = after_prefix[int_part.len..];
const frac = try p.getFracPart(after_int, prefix, tok_i);
const after_frac = after_int[frac.len..];
const exponent = try p.getExponent(after_frac, prefix, tok_i);
const suffix_str = after_frac[exponent.len..];
const is_float = (exponent.len > 0 or frac.len > 0);
const suffix = NumberSuffix.fromString(suffix_str, if (is_float) .float else .int) orelse {
if (is_float) {
try p.errStr(.invalid_float_suffix, tok_i, suffix_str);
} else {
try p.errStr(.invalid_int_suffix, tok_i, suffix_str);
}
return error.ParsingFailed;
};
if (suffix.isFloat80() and p.comp.float80Type() == null) {
try p.errStr(.invalid_float_suffix, tok_i, suffix_str);
return error.ParsingFailed;
}
if (is_float) {
assert(prefix == .hex or prefix == .decimal);
if (prefix == .hex and exponent.len == 0) {
try p.errTok(.hex_floating_constant_requires_exponent, tok_i);
return error.ParsingFailed;
}
const number = buf[0 .. buf.len - suffix_str.len];
return p.parseFloat(number, suffix, tok_i);
} else {
return p.parseInt(prefix, int_part, suffix, tok_i);
}
}
fn ppNum(p: *Parser) Error!Result {
defer p.tok_i += 1;
var res = try p.parseNumberToken(p.tok_i);
if (p.in_macro) {
if (res.ty.isFloat() or !res.ty.isReal()) {
try p.errTok(.float_literal_in_pp_expr, p.tok_i);
return error.ParsingFailed;
}
res.ty = if (res.ty.isUnsignedInt(p.comp)) p.comp.types.intmax.makeIntegerUnsigned() else p.comp.types.intmax;
} else if (res.val.opt_ref != .none) {
try p.value_map.put(res.node, res.val);
}
return res;
}
/// Run a parser function but do not evaluate the result
fn parseNoEval(p: *Parser, comptime func: fn (*Parser) Error!Result) Error!Result {
const no_eval = p.no_eval;
defer p.no_eval = no_eval;
p.no_eval = true;
const parsed = try func(p);
try parsed.expect(p);
return parsed;
}
/// genericSelection : keyword_generic '(' assignExpr ',' genericAssoc (',' genericAssoc)* ')'
/// genericAssoc
/// : typeName ':' assignExpr
/// | keyword_default ':' assignExpr
fn genericSelection(p: *Parser) Error!Result {
const kw_generic = p.tok_i;
p.tok_i += 1;
const l_paren = try p.expectToken(.l_paren);
const controlling_tok = p.tok_i;
const controlling = try p.parseNoEval(assignExpr);
_ = try p.expectToken(.comma);
var controlling_ty = controlling.ty;
if (controlling_ty.isArray()) controlling_ty.decayArray();
const list_buf_top = p.list_buf.items.len;
defer p.list_buf.items.len = list_buf_top;
try p.list_buf.append(controlling.node);
// Use decl_buf to store the token indexes of previous cases
const decl_buf_top = p.decl_buf.items.len;
defer p.decl_buf.items.len = decl_buf_top;
var default_tok: ?TokenIndex = null;
var default: Result = undefined;
var chosen_tok: TokenIndex = undefined;
var chosen: Result = .{};
while (true) {
const start = p.tok_i;
if (try p.typeName()) |ty| blk: {
if (ty.isArray()) {
try p.errTok(.generic_array_type, start);
} else if (ty.isFunc()) {
try p.errTok(.generic_func_type, start);
} else if (ty.anyQual()) {
try p.errTok(.generic_qual_type, start);
}
_ = try p.expectToken(.colon);
const node = try p.assignExpr();
try node.expect(p);
if (ty.eql(controlling_ty, p.comp, false)) {
if (chosen.node == .none) {
chosen = node;
chosen_tok = start;
break :blk;
}
try p.errStr(.generic_duplicate, start, try p.typeStr(ty));
try p.errStr(.generic_duplicate_here, chosen_tok, try p.typeStr(ty));
}
const list_buf = p.list_buf.items[list_buf_top + 1 ..];
const decl_buf = p.decl_buf.items[decl_buf_top..];
if (list_buf.len == decl_buf.len) {
// If these do not have the same length, there is already an error
for (list_buf, decl_buf) |item, prev_tok| {
const prev_ty = p.nodes.items(.ty)[@intFromEnum(item)];
if (prev_ty.eql(ty, p.comp, true)) {
try p.errStr(.generic_duplicate, start, try p.typeStr(ty));
try p.errStr(.generic_duplicate_here, @intFromEnum(prev_tok), try p.typeStr(ty));
}
}
}
try p.list_buf.append(try p.addNode(.{
.tag = .generic_association_expr,
.ty = ty,
.data = .{ .un = node.node },
.loc = @enumFromInt(start),
}));
try p.decl_buf.append(@enumFromInt(start));
} else if (p.eatToken(.keyword_default)) |tok| {
if (default_tok) |prev| {
try p.errTok(.generic_duplicate_default, tok);
try p.errTok(.previous_case, prev);
}
default_tok = tok;
_ = try p.expectToken(.colon);
default = try p.assignExpr();
try default.expect(p);
} else {
if (p.list_buf.items.len == list_buf_top + 1) {
try p.err(.expected_type);
return error.ParsingFailed;
}
break;
}
if (p.eatToken(.comma) == null) break;
}
try p.expectClosing(l_paren, .r_paren);
if (chosen.node == .none) {
if (default_tok) |tok| {
try p.list_buf.insert(list_buf_top + 1, try p.addNode(.{
.tag = .generic_default_expr,
.data = .{ .un = default.node },
.ty = default.ty,
.loc = @enumFromInt(tok),
}));
chosen = default;
} else {
try p.errStr(.generic_no_match, controlling_tok, try p.typeStr(controlling_ty));
return error.ParsingFailed;
}
} else {
try p.list_buf.insert(list_buf_top + 1, try p.addNode(.{
.tag = .generic_association_expr,
.data = .{ .un = chosen.node },
.ty = chosen.ty,
.loc = @enumFromInt(chosen_tok),
}));
if (default_tok) |tok| {
try p.list_buf.append(try p.addNode(.{
.tag = .generic_default_expr,
.data = .{ .un = default.node },
.ty = default.ty,
.loc = @enumFromInt(tok),
}));
}
}
var generic_node: Tree.Node = .{
.tag = .generic_expr_one,
.ty = chosen.ty,
.data = .{ .two = .{ controlling.node, chosen.node } },
.loc = @enumFromInt(kw_generic),
};
const associations = p.list_buf.items[list_buf_top..];
if (associations.len > 2) { // associations[0] == controlling.node
generic_node.tag = .generic_expr;
generic_node.data = .{ .range = try p.addList(associations) };
}
chosen.node = try p.addNode(generic_node);
return chosen;
}
test "Node locations" {
var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
defer comp.deinit();
const file = try comp.addSourceFromBuffer("file.c",
\\int foo = 5;
\\int bar = 10;
\\int main(void) {}
\\
);
const builtin_macros = try comp.generateBuiltinMacros(.no_system_defines);
var pp = Preprocessor.init(&comp);
defer pp.deinit();
try pp.addBuiltinMacros();
_ = try pp.preprocess(builtin_macros);
const eof = try pp.preprocess(file);
try pp.addToken(eof);
var tree = try Parser.parse(&pp);
defer tree.deinit();
try std.testing.expectEqual(0, comp.diagnostics.list.items.len);
for (tree.root_decls, 0..) |node, i| {
const tok_i = tree.nodeTok(node).?;
const slice = tree.tokSlice(tok_i);
const expected = switch (i) {
0 => "foo",
1 => "bar",
2 => "main",
else => unreachable,
};
try std.testing.expectEqualStrings(expected, slice);
}
}
|
0 | repos/arocc/src | repos/arocc/src/aro/annex_g.zig | //! Complex arithmetic algorithms from C99 Annex G
const std = @import("std");
const copysign = std.math.copysign;
const ilogb = std.math.ilogb;
const inf = std.math.inf;
const isFinite = std.math.isFinite;
const isInf = std.math.isInf;
const isNan = std.math.isNan;
const isPositiveZero = std.math.isPositiveZero;
const scalbn = std.math.scalbn;
/// computes floating point z*w where a_param, b_param are real, imaginary parts of z and c_param, d_param are real, imaginary parts of w
pub fn complexFloatMul(comptime T: type, a_param: T, b_param: T, c_param: T, d_param: T) [2]T {
var a = a_param;
var b = b_param;
var c = c_param;
var d = d_param;
const ac = a * c;
const bd = b * d;
const ad = a * d;
const bc = b * c;
var x = ac - bd;
var y = ad + bc;
if (isNan(x) and isNan(y)) {
var recalc = false;
if (isInf(a) or isInf(b)) {
// lhs infinite
// Box the infinity and change NaNs in the other factor to 0
a = copysign(if (isInf(a)) @as(T, 1.0) else @as(T, 0.0), a);
b = copysign(if (isInf(b)) @as(T, 1.0) else @as(T, 0.0), b);
if (isNan(c)) c = copysign(@as(T, 0.0), c);
if (isNan(d)) d = copysign(@as(T, 0.0), d);
recalc = true;
}
if (isInf(c) or isInf(d)) {
// rhs infinite
// Box the infinity and change NaNs in the other factor to 0
c = copysign(if (isInf(c)) @as(T, 1.0) else @as(T, 0.0), c);
d = copysign(if (isInf(d)) @as(T, 1.0) else @as(T, 0.0), d);
if (isNan(a)) a = copysign(@as(T, 0.0), a);
if (isNan(b)) b = copysign(@as(T, 0.0), b);
recalc = true;
}
if (!recalc and (isInf(ac) or isInf(bd) or isInf(ad) or isInf(bc))) {
// Recover infinities from overflow by changing NaN's to 0
if (isNan(a)) a = copysign(@as(T, 0.0), a);
if (isNan(b)) b = copysign(@as(T, 0.0), b);
if (isNan(c)) c = copysign(@as(T, 0.0), c);
if (isNan(d)) d = copysign(@as(T, 0.0), d);
}
if (recalc) {
x = inf(T) * (a * c - b * d);
y = inf(T) * (a * d + b * c);
}
}
return .{ x, y };
}
/// computes floating point z / w where a_param, b_param are real, imaginary parts of z and c_param, d_param are real, imaginary parts of w
pub fn complexFloatDiv(comptime T: type, a_param: T, b_param: T, c_param: T, d_param: T) [2]T {
var a = a_param;
var b = b_param;
var c = c_param;
var d = d_param;
var denom_logb: i32 = 0;
const max_cd = @max(@abs(c), @abs(d));
if (isFinite(max_cd)) {
if (max_cd == 0) {
denom_logb = std.math.minInt(i32) + 1;
c = 0;
d = 0;
} else {
denom_logb = ilogb(max_cd);
c = scalbn(c, -denom_logb);
d = scalbn(d, -denom_logb);
}
}
const denom = c * c + d * d;
var x = scalbn((a * c + b * d) / denom, -denom_logb);
var y = scalbn((b * c - a * d) / denom, -denom_logb);
if (isNan(x) and isNan(y)) {
if (isPositiveZero(denom) and (!isNan(a) or !isNan(b))) {
x = copysign(inf(T), c) * a;
y = copysign(inf(T), c) * b;
} else if ((isInf(a) or isInf(b)) and isFinite(c) and isFinite(d)) {
a = copysign(if (isInf(a)) @as(T, 1.0) else @as(T, 0.0), a);
b = copysign(if (isInf(b)) @as(T, 1.0) else @as(T, 0.0), b);
x = inf(T) * (a * c + b * d);
y = inf(T) * (b * c - a * d);
} else if (isInf(max_cd) and isFinite(a) and isFinite(b)) {
c = copysign(if (isInf(c)) @as(T, 1.0) else @as(T, 0.0), c);
d = copysign(if (isInf(d)) @as(T, 1.0) else @as(T, 0.0), d);
x = 0.0 * (a * c + b * d);
y = 0.0 * (b * c - a * d);
}
}
return .{ x, y };
}
test complexFloatMul {
// Naive algorithm would produce NaN + NaNi instead of inf + NaNi
const result = complexFloatMul(f64, inf(f64), std.math.nan(f64), 2, 0);
try std.testing.expect(isInf(result[0]));
try std.testing.expect(isNan(result[1]));
}
test complexFloatDiv {
// Naive algorithm would produce NaN + NaNi instead of inf + NaNi
var result = complexFloatDiv(f64, inf(f64), std.math.nan(f64), 2, 0);
try std.testing.expect(isInf(result[0]));
try std.testing.expect(isNan(result[1]));
result = complexFloatDiv(f64, 2.0, 2.0, 0.0, 0.0);
try std.testing.expect(isInf(result[0]));
try std.testing.expect(isInf(result[1]));
}
|
0 | repos/arocc/src | repos/arocc/src/aro/Driver.zig | const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const process = std.process;
const backend = @import("backend");
const Ir = backend.Ir;
const Object = backend.Object;
const Compilation = @import("Compilation.zig");
const Diagnostics = @import("Diagnostics.zig");
const LangOpts = @import("LangOpts.zig");
const Preprocessor = @import("Preprocessor.zig");
const Source = @import("Source.zig");
const Toolchain = @import("Toolchain.zig");
const target_util = @import("target.zig");
const GCCVersion = @import("Driver/GCCVersion.zig");
pub const Linker = enum {
ld,
bfd,
gold,
lld,
mold,
};
const Driver = @This();
comp: *Compilation,
inputs: std.ArrayListUnmanaged(Source) = .{},
link_objects: std.ArrayListUnmanaged([]const u8) = .{},
output_name: ?[]const u8 = null,
sysroot: ?[]const u8 = null,
system_defines: Compilation.SystemDefinesMode = .include_system_defines,
temp_file_count: u32 = 0,
/// If false, do not emit line directives in -E mode
line_commands: bool = true,
/// If true, use `#line <num>` instead of `# <num>` for line directives
use_line_directives: bool = false,
only_preprocess: bool = false,
only_syntax: bool = false,
only_compile: bool = false,
only_preprocess_and_compile: bool = false,
verbose_ast: bool = false,
verbose_pp: bool = false,
verbose_ir: bool = false,
verbose_linker_args: bool = false,
color: ?bool = null,
nobuiltininc: bool = false,
nostdinc: bool = false,
nostdlibinc: bool = false,
debug_dump_letters: packed struct(u3) {
d: bool = false,
m: bool = false,
n: bool = false,
/// According to GCC, specifying letters whose behavior conflicts is undefined.
/// We follow clang in that `-dM` always takes precedence over `-dD`
pub fn getPreprocessorDumpMode(self: @This()) Preprocessor.DumpMode {
if (self.m) return .macros_only;
if (self.d) return .macros_and_result;
if (self.n) return .macro_names_and_result;
return .result_only;
}
} = .{},
/// Full path to the aro executable
aro_name: []const u8 = "",
/// Value of --triple= passed via CLI
raw_target_triple: ?[]const u8 = null,
// linker options
use_linker: ?[]const u8 = null,
linker_path: ?[]const u8 = null,
nodefaultlibs: bool = false,
nolibc: bool = false,
nostartfiles: bool = false,
nostdlib: bool = false,
pie: ?bool = null,
rdynamic: bool = false,
relocatable: bool = false,
rtlib: ?[]const u8 = null,
shared: bool = false,
shared_libgcc: bool = false,
static: bool = false,
static_libgcc: bool = false,
static_pie: bool = false,
strip: bool = false,
unwindlib: ?[]const u8 = null,
pub fn deinit(d: *Driver) void {
for (d.link_objects.items[d.link_objects.items.len - d.temp_file_count ..]) |obj| {
std.fs.deleteFileAbsolute(obj) catch {};
d.comp.gpa.free(obj);
}
d.inputs.deinit(d.comp.gpa);
d.link_objects.deinit(d.comp.gpa);
d.* = undefined;
}
pub const usage =
\\Usage {s}: [options] file..
\\
\\General options:
\\ -h, --help Print this message.
\\ -v, --version Print aro version.
\\
\\Compile options:
\\ -c, --compile Only run preprocess, compile, and assemble steps
\\ -dM Output #define directives for all the macros defined during the execution of the preprocessor
\\ -dD Like -dM except that it outputs both the #define directives and the result of preprocessing
\\ -dN Like -dD, but emit only the macro names, not their expansions.
\\ -D <macro>=<value> Define <macro> to <value> (defaults to 1)
\\ -E Only run the preprocessor
\\ -fchar8_t Enable char8_t (enabled by default in C23 and later)
\\ -fno-char8_t Disable char8_t (disabled by default for pre-C23)
\\ -fcolor-diagnostics Enable colors in diagnostics
\\ -fno-color-diagnostics Disable colors in diagnostics
\\ -fdeclspec Enable support for __declspec attributes
\\ -fgnuc-version=<value> Controls value of __GNUC__ and related macros. Set to 0 or empty to disable them.
\\ -fno-declspec Disable support for __declspec attributes
\\ -ffp-eval-method=[source|double|extended]
\\ Evaluation method to use for floating-point arithmetic
\\ -ffreestanding Compilation in a freestanding environment
\\ -fgnu-inline-asm Enable GNU style inline asm (default: enabled)
\\ -fno-gnu-inline-asm Disable GNU style inline asm
\\ -fhosted Compilation in a hosted environment
\\ -fms-extensions Enable support for Microsoft extensions
\\ -fno-ms-extensions Disable support for Microsoft extensions
\\ -fdollars-in-identifiers
\\ Allow '$' in identifiers
\\ -fno-dollars-in-identifiers
\\ Disallow '$' in identifiers
\\ -fmacro-backtrace-limit=<limit>
\\ Set limit on how many macro expansion traces are shown in errors (default 6)
\\ -fnative-half-type Use the native half type for __fp16 instead of promoting to float
\\ -fnative-half-arguments-and-returns
\\ Allow half-precision function arguments and return values
\\ -fshort-enums Use the narrowest possible integer type for enums
\\ -fno-short-enums Use "int" as the tag type for enums
\\ -fsigned-char "char" is signed
\\ -fno-signed-char "char" is unsigned
\\ -fsyntax-only Only run the preprocessor, parser, and semantic analysis stages
\\ -funsigned-char "char" is unsigned
\\ -fno-unsigned-char "char" is signed
\\ -fuse-line-directives Use `#line <num>` linemarkers in preprocessed output
\\ -fno-use-line-directives
\\ Use `# <num>` linemarkers in preprocessed output
\\ -I <dir> Add directory to include search path
\\ -isystem Add directory to SYSTEM include search path
\\ --emulate=[clang|gcc|msvc]
\\ Select which C compiler to emulate (default clang)
\\ -nobuiltininc Do not search the compiler's builtin directory for include files
\\ -nostdinc, --no-standard-includes
\\ Do not search the standard system directories or compiler builtin directories for include files.
\\ -nostdlibinc Do not search the standard system directories for include files, but do search compiler builtin include directories
\\ -o <file> Write output to <file>
\\ -P, --no-line-commands Disable linemarker output in -E mode
\\ -pedantic Warn on language extensions
\\ --rtlib=<arg> Compiler runtime library to use (libgcc or compiler-rt)
\\ -std=<standard> Specify language standard
\\ -S, --assemble Only run preprocess and compilation steps
\\ --sysroot=<dir> Use dir as the logical root directory for headers and libraries (not fully implemented)
\\ --target=<value> Generate code for the given target
\\ -U <macro> Undefine <macro>
\\ -undef Do not predefine any system-specific macros. Standard predefined macros remain defined.
\\ -Werror Treat all warnings as errors
\\ -Werror=<warning> Treat warning as error
\\ -W<warning> Enable the specified warning
\\ -Wno-<warning> Disable the specified warning
\\
\\Link options:
\\ -fuse-ld=[bfd|gold|lld|mold]
\\ Use specific linker
\\ -nodefaultlibs Do not use the standard system libraries when linking.
\\ -nolibc Do not use the C library or system libraries tightly coupled with it when linking.
\\ -nostdlib Do not use the standard system startup files or libraries when linking
\\ -nostartfiles Do not use the standard system startup files when linking.
\\ -pie Produce a dynamically linked position independent executable on targets that support it.
\\ --ld-path=<path> Use linker specified by <path>
\\ -r Produce a relocatable object as output.
\\ -rdynamic Pass the flag -export-dynamic to the ELF linker, on targets that support it.
\\ -s Remove all symbol table and relocation information from the executable.
\\ -shared Produce a shared object which can then be linked with other objects to form an executable.
\\ -shared-libgcc On systems that provide libgcc as a shared library, force the use of the shared version
\\ -static On systems that support dynamic linking, this overrides -pie and prevents linking with the shared libraries.
\\ -static-libgcc On systems that provide libgcc as a shared library, force the use of the static version
\\ -static-pie Produce a static position independent executable on targets that support it.
\\ --unwindlib=<arg> Unwind library to use ("none", "libgcc", or "libunwind") If not specified, will match runtime library
\\
\\Debug options:
\\ --verbose-ast Dump produced AST to stdout
\\ --verbose-pp Dump preprocessor state
\\ --verbose-ir Dump ir to stdout
\\ --verbose-linker-args Dump linker args to stdout
\\
\\
;
/// Process command line arguments, returns true if something was written to std_out.
pub fn parseArgs(
d: *Driver,
std_out: anytype,
macro_buf: anytype,
args: []const []const u8,
) !bool {
var i: usize = 1;
var comment_arg: []const u8 = "";
var hosted: ?bool = null;
var gnuc_version: []const u8 = "4.2.1"; // default value set by clang
while (i < args.len) : (i += 1) {
const arg = args[i];
if (mem.startsWith(u8, arg, "-") and arg.len > 1) {
if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
std_out.print(usage, .{args[0]}) catch |er| {
return d.fatal("unable to print usage: {s}", .{errorDescription(er)});
};
return true;
} else if (mem.eql(u8, arg, "-v") or mem.eql(u8, arg, "--version")) {
std_out.writeAll(@import("backend").version_str ++ "\n") catch |er| {
return d.fatal("unable to print version: {s}", .{errorDescription(er)});
};
return true;
} else if (mem.startsWith(u8, arg, "-D")) {
var macro = arg["-D".len..];
if (macro.len == 0) {
i += 1;
if (i >= args.len) {
try d.err("expected argument after -I");
continue;
}
macro = args[i];
}
var value: []const u8 = "1";
if (mem.indexOfScalar(u8, macro, '=')) |some| {
value = macro[some + 1 ..];
macro = macro[0..some];
}
try macro_buf.print("#define {s} {s}\n", .{ macro, value });
} else if (mem.startsWith(u8, arg, "-U")) {
var macro = arg["-U".len..];
if (macro.len == 0) {
i += 1;
if (i >= args.len) {
try d.err("expected argument after -I");
continue;
}
macro = args[i];
}
try macro_buf.print("#undef {s}\n", .{macro});
} else if (mem.eql(u8, arg, "-undef")) {
d.system_defines = .no_system_defines;
} else if (mem.eql(u8, arg, "-c") or mem.eql(u8, arg, "--compile")) {
d.only_compile = true;
} else if (mem.eql(u8, arg, "-dD")) {
d.debug_dump_letters.d = true;
} else if (mem.eql(u8, arg, "-dM")) {
d.debug_dump_letters.m = true;
} else if (mem.eql(u8, arg, "-dN")) {
d.debug_dump_letters.n = true;
} else if (mem.eql(u8, arg, "-E")) {
d.only_preprocess = true;
} else if (mem.eql(u8, arg, "-P") or mem.eql(u8, arg, "--no-line-commands")) {
d.line_commands = false;
} else if (mem.eql(u8, arg, "-fuse-line-directives")) {
d.use_line_directives = true;
} else if (mem.eql(u8, arg, "-fno-use-line-directives")) {
d.use_line_directives = false;
} else if (mem.eql(u8, arg, "-fchar8_t")) {
d.comp.langopts.has_char8_t_override = true;
} else if (mem.eql(u8, arg, "-fno-char8_t")) {
d.comp.langopts.has_char8_t_override = false;
} else if (mem.eql(u8, arg, "-fcolor-diagnostics")) {
d.color = true;
} else if (mem.eql(u8, arg, "-fno-color-diagnostics")) {
d.color = false;
} else if (mem.eql(u8, arg, "-fdollars-in-identifiers")) {
d.comp.langopts.dollars_in_identifiers = true;
} else if (mem.eql(u8, arg, "-fno-dollars-in-identifiers")) {
d.comp.langopts.dollars_in_identifiers = false;
} else if (mem.eql(u8, arg, "-fdigraphs")) {
d.comp.langopts.digraphs = true;
} else if (mem.eql(u8, arg, "-fgnu-inline-asm")) {
d.comp.langopts.gnu_asm = true;
} else if (mem.eql(u8, arg, "-fno-gnu-inline-asm")) {
d.comp.langopts.gnu_asm = false;
} else if (mem.eql(u8, arg, "-fno-digraphs")) {
d.comp.langopts.digraphs = false;
} else if (option(arg, "-fmacro-backtrace-limit=")) |limit_str| {
var limit = std.fmt.parseInt(u32, limit_str, 10) catch {
try d.err("-fmacro-backtrace-limit takes a number argument");
continue;
};
if (limit == 0) limit = std.math.maxInt(u32);
d.comp.diagnostics.macro_backtrace_limit = limit;
} else if (mem.eql(u8, arg, "-fnative-half-type")) {
d.comp.langopts.use_native_half_type = true;
} else if (mem.eql(u8, arg, "-fnative-half-arguments-and-returns")) {
d.comp.langopts.allow_half_args_and_returns = true;
} else if (mem.eql(u8, arg, "-fshort-enums")) {
d.comp.langopts.short_enums = true;
} else if (mem.eql(u8, arg, "-fno-short-enums")) {
d.comp.langopts.short_enums = false;
} else if (mem.eql(u8, arg, "-fsigned-char")) {
d.comp.langopts.setCharSignedness(.signed);
} else if (mem.eql(u8, arg, "-fno-signed-char")) {
d.comp.langopts.setCharSignedness(.unsigned);
} else if (mem.eql(u8, arg, "-funsigned-char")) {
d.comp.langopts.setCharSignedness(.unsigned);
} else if (mem.eql(u8, arg, "-fno-unsigned-char")) {
d.comp.langopts.setCharSignedness(.signed);
} else if (mem.eql(u8, arg, "-fdeclspec")) {
d.comp.langopts.declspec_attrs = true;
} else if (mem.eql(u8, arg, "-fno-declspec")) {
d.comp.langopts.declspec_attrs = false;
} else if (mem.eql(u8, arg, "-ffreestanding")) {
hosted = false;
} else if (mem.eql(u8, arg, "-fhosted")) {
hosted = true;
} else if (mem.eql(u8, arg, "-fms-extensions")) {
d.comp.langopts.enableMSExtensions();
} else if (mem.eql(u8, arg, "-fno-ms-extensions")) {
d.comp.langopts.disableMSExtensions();
} else if (mem.startsWith(u8, arg, "-I")) {
var path = arg["-I".len..];
if (path.len == 0) {
i += 1;
if (i >= args.len) {
try d.err("expected argument after -I");
continue;
}
path = args[i];
}
try d.comp.include_dirs.append(d.comp.gpa, path);
} else if (mem.startsWith(u8, arg, "-fsyntax-only")) {
d.only_syntax = true;
} else if (mem.startsWith(u8, arg, "-fno-syntax-only")) {
d.only_syntax = false;
} else if (mem.eql(u8, arg, "-fgnuc-version=")) {
gnuc_version = "0";
} else if (option(arg, "-fgnuc-version=")) |version| {
gnuc_version = version;
} else if (mem.startsWith(u8, arg, "-isystem")) {
var path = arg["-isystem".len..];
if (path.len == 0) {
i += 1;
if (i >= args.len) {
try d.err("expected argument after -isystem");
continue;
}
path = args[i];
}
const duped = try d.comp.gpa.dupe(u8, path);
errdefer d.comp.gpa.free(duped);
try d.comp.system_include_dirs.append(d.comp.gpa, duped);
} else if (option(arg, "--emulate=")) |compiler_str| {
const compiler = std.meta.stringToEnum(LangOpts.Compiler, compiler_str) orelse {
try d.comp.addDiagnostic(.{ .tag = .cli_invalid_emulate, .extra = .{ .str = arg } }, &.{});
continue;
};
d.comp.langopts.setEmulatedCompiler(compiler);
} else if (option(arg, "-ffp-eval-method=")) |fp_method_str| {
const fp_eval_method = std.meta.stringToEnum(LangOpts.FPEvalMethod, fp_method_str) orelse .indeterminate;
if (fp_eval_method == .indeterminate) {
try d.comp.addDiagnostic(.{ .tag = .cli_invalid_fp_eval_method, .extra = .{ .str = fp_method_str } }, &.{});
continue;
}
d.comp.langopts.setFpEvalMethod(fp_eval_method);
} else if (mem.startsWith(u8, arg, "-o")) {
var file = arg["-o".len..];
if (file.len == 0) {
i += 1;
if (i >= args.len) {
try d.err("expected argument after -o");
continue;
}
file = args[i];
}
d.output_name = file;
} else if (option(arg, "--sysroot=")) |sysroot| {
d.sysroot = sysroot;
} else if (mem.eql(u8, arg, "-pedantic")) {
d.comp.diagnostics.options.pedantic = .warning;
} else if (option(arg, "--rtlib=")) |rtlib| {
if (mem.eql(u8, rtlib, "compiler-rt") or mem.eql(u8, rtlib, "libgcc") or mem.eql(u8, rtlib, "platform")) {
d.rtlib = rtlib;
} else {
try d.comp.addDiagnostic(.{ .tag = .invalid_rtlib, .extra = .{ .str = rtlib } }, &.{});
}
} else if (option(arg, "-Werror=")) |err_name| {
try d.comp.diagnostics.set(err_name, .@"error");
} else if (mem.eql(u8, arg, "-Wno-fatal-errors")) {
d.comp.diagnostics.fatal_errors = false;
} else if (option(arg, "-Wno-")) |err_name| {
try d.comp.diagnostics.set(err_name, .off);
} else if (mem.eql(u8, arg, "-Wfatal-errors")) {
d.comp.diagnostics.fatal_errors = true;
} else if (option(arg, "-W")) |err_name| {
try d.comp.diagnostics.set(err_name, .warning);
} else if (option(arg, "-std=")) |standard| {
d.comp.langopts.setStandard(standard) catch
try d.comp.addDiagnostic(.{ .tag = .cli_invalid_standard, .extra = .{ .str = arg } }, &.{});
} else if (mem.eql(u8, arg, "-S") or mem.eql(u8, arg, "--assemble")) {
d.only_preprocess_and_compile = true;
} else if (option(arg, "--target=")) |triple| {
const query = std.Target.Query.parse(.{ .arch_os_abi = triple }) catch {
try d.comp.addDiagnostic(.{ .tag = .cli_invalid_target, .extra = .{ .str = arg } }, &.{});
continue;
};
const target = std.zig.system.resolveTargetQuery(query) catch |e| {
return d.fatal("unable to resolve target: {s}", .{errorDescription(e)});
};
d.comp.target = target;
d.comp.langopts.setEmulatedCompiler(target_util.systemCompiler(target));
d.raw_target_triple = triple;
} else if (mem.eql(u8, arg, "--verbose-ast")) {
d.verbose_ast = true;
} else if (mem.eql(u8, arg, "--verbose-pp")) {
d.verbose_pp = true;
} else if (mem.eql(u8, arg, "--verbose-ir")) {
d.verbose_ir = true;
} else if (mem.eql(u8, arg, "--verbose-linker-args")) {
d.verbose_linker_args = true;
} else if (mem.eql(u8, arg, "-C") or mem.eql(u8, arg, "--comments")) {
d.comp.langopts.preserve_comments = true;
comment_arg = arg;
} else if (mem.eql(u8, arg, "-CC") or mem.eql(u8, arg, "--comments-in-macros")) {
d.comp.langopts.preserve_comments = true;
d.comp.langopts.preserve_comments_in_macros = true;
comment_arg = arg;
} else if (option(arg, "-fuse-ld=")) |linker_name| {
d.use_linker = linker_name;
} else if (mem.eql(u8, arg, "-fuse-ld=")) {
d.use_linker = null;
} else if (option(arg, "--ld-path=")) |linker_path| {
d.linker_path = linker_path;
} else if (mem.eql(u8, arg, "-r")) {
d.relocatable = true;
} else if (mem.eql(u8, arg, "-shared")) {
d.shared = true;
} else if (mem.eql(u8, arg, "-shared-libgcc")) {
d.shared_libgcc = true;
} else if (mem.eql(u8, arg, "-static")) {
d.static = true;
} else if (mem.eql(u8, arg, "-static-libgcc")) {
d.static_libgcc = true;
} else if (mem.eql(u8, arg, "-static-pie")) {
d.static_pie = true;
} else if (mem.eql(u8, arg, "-pie")) {
d.pie = true;
} else if (mem.eql(u8, arg, "-no-pie") or mem.eql(u8, arg, "-nopie")) {
d.pie = false;
} else if (mem.eql(u8, arg, "-rdynamic")) {
d.rdynamic = true;
} else if (mem.eql(u8, arg, "-s")) {
d.strip = true;
} else if (mem.eql(u8, arg, "-nodefaultlibs")) {
d.nodefaultlibs = true;
} else if (mem.eql(u8, arg, "-nolibc")) {
d.nolibc = true;
} else if (mem.eql(u8, arg, "-nobuiltininc")) {
d.nobuiltininc = true;
} else if (mem.eql(u8, arg, "-nostdinc") or mem.eql(u8, arg, "--no-standard-includes")) {
d.nostdinc = true;
} else if (mem.eql(u8, arg, "-nostdlibinc")) {
d.nostdlibinc = true;
} else if (mem.eql(u8, arg, "-nostdlib")) {
d.nostdlib = true;
} else if (mem.eql(u8, arg, "-nostartfiles")) {
d.nostartfiles = true;
} else if (option(arg, "--unwindlib=")) |unwindlib| {
const valid_unwindlibs: [5][]const u8 = .{ "", "none", "platform", "libunwind", "libgcc" };
for (valid_unwindlibs) |name| {
if (mem.eql(u8, name, unwindlib)) {
d.unwindlib = unwindlib;
break;
}
} else {
try d.comp.addDiagnostic(.{ .tag = .invalid_unwindlib, .extra = .{ .str = unwindlib } }, &.{});
}
} else {
try d.comp.addDiagnostic(.{ .tag = .cli_unknown_arg, .extra = .{ .str = arg } }, &.{});
}
} else if (std.mem.endsWith(u8, arg, ".o") or std.mem.endsWith(u8, arg, ".obj")) {
try d.link_objects.append(d.comp.gpa, arg);
} else {
const source = d.addSource(arg) catch |er| {
return d.fatal("unable to add source file '{s}': {s}", .{ arg, errorDescription(er) });
};
try d.inputs.append(d.comp.gpa, source);
}
}
if (d.comp.langopts.preserve_comments and !d.only_preprocess) {
return d.fatal("invalid argument '{s}' only allowed with '-E'", .{comment_arg});
}
if (hosted) |is_hosted| {
if (is_hosted) {
if (d.comp.target.os.tag == .freestanding) {
return d.fatal("Cannot use freestanding target with `-fhosted`", .{});
}
} else {
d.comp.target.os.tag = .freestanding;
}
}
const version = GCCVersion.parse(gnuc_version);
if (version.major == -1) {
return d.fatal("invalid value '{0s}' in '-fgnuc-version={0s}'", .{gnuc_version});
}
d.comp.langopts.gnuc_version = version.toUnsigned();
return false;
}
fn option(arg: []const u8, name: []const u8) ?[]const u8 {
if (std.mem.startsWith(u8, arg, name) and arg.len > name.len) {
return arg[name.len..];
}
return null;
}
fn addSource(d: *Driver, path: []const u8) !Source {
if (mem.eql(u8, "-", path)) {
const stdin = std.io.getStdIn().reader();
const input = try stdin.readAllAlloc(d.comp.gpa, std.math.maxInt(u32));
defer d.comp.gpa.free(input);
return d.comp.addSourceFromBuffer("<stdin>", input);
}
return d.comp.addSourceFromPath(path);
}
pub fn err(d: *Driver, msg: []const u8) !void {
try d.comp.addDiagnostic(.{ .tag = .cli_error, .extra = .{ .str = msg } }, &.{});
}
pub fn fatal(d: *Driver, comptime fmt: []const u8, args: anytype) error{ FatalError, OutOfMemory } {
try d.comp.diagnostics.list.append(d.comp.gpa, .{
.tag = .cli_error,
.kind = .@"fatal error",
.extra = .{ .str = try std.fmt.allocPrint(d.comp.diagnostics.arena.allocator(), fmt, args) },
});
return error.FatalError;
}
pub fn renderErrors(d: *Driver) void {
Diagnostics.render(d.comp, d.detectConfig(std.io.getStdErr()));
}
pub fn detectConfig(d: *Driver, file: std.fs.File) std.io.tty.Config {
if (d.color == true) return .escape_codes;
if (d.color == false) return .no_color;
if (file.supportsAnsiEscapeCodes()) return .escape_codes;
if (@import("builtin").os.tag == .windows and file.isTty()) {
var info: std.os.windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
if (std.os.windows.kernel32.GetConsoleScreenBufferInfo(file.handle, &info) != std.os.windows.TRUE) {
return .no_color;
}
return .{ .windows_api = .{
.handle = file.handle,
.reset_attributes = info.wAttributes,
} };
}
return .no_color;
}
pub fn errorDescription(e: anyerror) []const u8 {
return switch (e) {
error.OutOfMemory => "ran out of memory",
error.FileNotFound => "file not found",
error.IsDir => "is a directory",
error.NotDir => "is not a directory",
error.NotOpenForReading => "file is not open for reading",
error.NotOpenForWriting => "file is not open for writing",
error.InvalidUtf8 => "path is not valid UTF-8",
error.InvalidWtf8 => "path is not valid WTF-8",
error.FileBusy => "file is busy",
error.NameTooLong => "file name is too long",
error.AccessDenied => "access denied",
error.FileTooBig => "file is too big",
error.ProcessFdQuotaExceeded, error.SystemFdQuotaExceeded => "ran out of file descriptors",
error.SystemResources => "ran out of system resources",
error.FatalError => "a fatal error occurred",
error.Unexpected => "an unexpected error occurred",
else => @errorName(e),
};
}
/// The entry point of the Aro compiler.
/// **MAY call `exit` if `fast_exit` is set.**
pub fn main(d: *Driver, tc: *Toolchain, args: []const []const u8, comptime fast_exit: bool) !void {
var macro_buf = std.ArrayList(u8).init(d.comp.gpa);
defer macro_buf.deinit();
const std_out = std.io.getStdOut().writer();
if (try parseArgs(d, std_out, macro_buf.writer(), args)) return;
const linking = !(d.only_preprocess or d.only_syntax or d.only_compile or d.only_preprocess_and_compile);
if (d.inputs.items.len == 0) {
return d.fatal("no input files", .{});
} else if (d.inputs.items.len != 1 and d.output_name != null and !linking) {
return d.fatal("cannot specify -o when generating multiple output files", .{});
}
if (!linking) for (d.link_objects.items) |obj| {
try d.comp.addDiagnostic(.{ .tag = .cli_unused_link_object, .extra = .{ .str = obj } }, &.{});
};
try tc.discover();
tc.defineSystemIncludes() catch |er| switch (er) {
error.OutOfMemory => return error.OutOfMemory,
error.AroIncludeNotFound => return d.fatal("unable to find Aro builtin headers", .{}),
};
const builtin = try d.comp.generateBuiltinMacros(d.system_defines);
const user_macros = try d.comp.addSourceFromBuffer("<command line>", macro_buf.items);
if (fast_exit and d.inputs.items.len == 1) {
d.processSource(tc, d.inputs.items[0], builtin, user_macros, fast_exit) catch |e| switch (e) {
error.FatalError => {
d.renderErrors();
d.exitWithCleanup(1);
},
else => |er| return er,
};
unreachable;
}
for (d.inputs.items) |source| {
d.processSource(tc, source, builtin, user_macros, fast_exit) catch |e| switch (e) {
error.FatalError => {
d.renderErrors();
},
else => |er| return er,
};
}
if (d.comp.diagnostics.errors != 0) {
if (fast_exit) d.exitWithCleanup(1);
return;
}
if (linking) {
try d.invokeLinker(tc, fast_exit);
}
if (fast_exit) std.process.exit(0);
}
fn processSource(
d: *Driver,
tc: *Toolchain,
source: Source,
builtin: Source,
user_macros: Source,
comptime fast_exit: bool,
) !void {
d.comp.generated_buf.items.len = 0;
var pp = try Preprocessor.initDefault(d.comp);
defer pp.deinit();
if (d.comp.langopts.ms_extensions) {
d.comp.ms_cwd_source_id = source.id;
}
const dump_mode = d.debug_dump_letters.getPreprocessorDumpMode();
if (d.verbose_pp) pp.verbose = true;
if (d.only_preprocess) {
pp.preserve_whitespace = true;
if (d.line_commands) {
pp.linemarkers = if (d.use_line_directives) .line_directives else .numeric_directives;
}
switch (dump_mode) {
.macros_and_result, .macro_names_and_result => pp.store_macro_tokens = true,
.result_only, .macros_only => {},
}
}
try pp.preprocessSources(&.{ source, builtin, user_macros });
if (d.only_preprocess) {
d.renderErrors();
if (d.comp.diagnostics.errors != 0) {
if (fast_exit) std.process.exit(1); // Not linking, no need for cleanup.
return;
}
const file = if (d.output_name) |some|
std.fs.cwd().createFile(some, .{}) catch |er|
return d.fatal("unable to create output file '{s}': {s}", .{ some, errorDescription(er) })
else
std.io.getStdOut();
defer if (d.output_name != null) file.close();
var buf_w = std.io.bufferedWriter(file.writer());
pp.prettyPrintTokens(buf_w.writer(), dump_mode) catch |er|
return d.fatal("unable to write result: {s}", .{errorDescription(er)});
buf_w.flush() catch |er|
return d.fatal("unable to write result: {s}", .{errorDescription(er)});
if (fast_exit) std.process.exit(0); // Not linking, no need for cleanup.
return;
}
var tree = try pp.parse();
defer tree.deinit();
if (d.verbose_ast) {
const stdout = std.io.getStdOut();
var buf_writer = std.io.bufferedWriter(stdout.writer());
tree.dump(d.detectConfig(stdout), buf_writer.writer()) catch {};
buf_writer.flush() catch {};
}
const prev_errors = d.comp.diagnostics.errors;
d.renderErrors();
if (d.comp.diagnostics.errors != prev_errors) {
if (fast_exit) d.exitWithCleanup(1);
return; // do not compile if there were errors
}
if (d.only_syntax) {
if (fast_exit) std.process.exit(0); // Not linking, no need for cleanup.
return;
}
if (d.comp.target.ofmt != .elf or d.comp.target.cpu.arch != .x86_64) {
return d.fatal(
"unsupported target {s}-{s}-{s}, currently only x86-64 elf is supported",
.{ @tagName(d.comp.target.cpu.arch), @tagName(d.comp.target.os.tag), @tagName(d.comp.target.abi) },
);
}
var ir = try tree.genIr();
defer ir.deinit(d.comp.gpa);
if (d.verbose_ir) {
const stdout = std.io.getStdOut();
var buf_writer = std.io.bufferedWriter(stdout.writer());
ir.dump(d.comp.gpa, d.detectConfig(stdout), buf_writer.writer()) catch {};
buf_writer.flush() catch {};
}
var render_errors: Ir.Renderer.ErrorList = .{};
defer {
for (render_errors.values()) |msg| d.comp.gpa.free(msg);
render_errors.deinit(d.comp.gpa);
}
var obj = ir.render(d.comp.gpa, d.comp.target, &render_errors) catch |e| switch (e) {
error.OutOfMemory => return error.OutOfMemory,
error.LowerFail => {
return d.fatal(
"unable to render Ir to machine code: {s}",
.{render_errors.values()[0]},
);
},
};
defer obj.deinit();
// If it's used, name_buf will either hold a filename or `/tmp/<12 random bytes with base-64 encoding>.<extension>`
// both of which should fit into MAX_NAME_BYTES for all systems
var name_buf: [std.fs.MAX_NAME_BYTES]u8 = undefined;
const out_file_name = if (d.only_compile) blk: {
const fmt_template = "{s}{s}";
const fmt_args = .{
std.fs.path.stem(source.path),
d.comp.target.ofmt.fileExt(d.comp.target.cpu.arch),
};
break :blk d.output_name orelse
std.fmt.bufPrint(&name_buf, fmt_template, fmt_args) catch return d.fatal("Filename too long for filesystem: " ++ fmt_template, fmt_args);
} else blk: {
const random_bytes_count = 12;
const sub_path_len = comptime std.fs.base64_encoder.calcSize(random_bytes_count);
var random_bytes: [random_bytes_count]u8 = undefined;
std.crypto.random.bytes(&random_bytes);
var random_name: [sub_path_len]u8 = undefined;
_ = std.fs.base64_encoder.encode(&random_name, &random_bytes);
const fmt_template = "/tmp/{s}{s}";
const fmt_args = .{
random_name,
d.comp.target.ofmt.fileExt(d.comp.target.cpu.arch),
};
break :blk std.fmt.bufPrint(&name_buf, fmt_template, fmt_args) catch return d.fatal("Filename too long for filesystem: " ++ fmt_template, fmt_args);
};
const out_file = std.fs.cwd().createFile(out_file_name, .{}) catch |er|
return d.fatal("unable to create output file '{s}': {s}", .{ out_file_name, errorDescription(er) });
defer out_file.close();
obj.finish(out_file) catch |er|
return d.fatal("could not output to object file '{s}': {s}", .{ out_file_name, errorDescription(er) });
if (d.only_compile) {
if (fast_exit) std.process.exit(0); // Not linking, no need for cleanup.
return;
}
try d.link_objects.ensureUnusedCapacity(d.comp.gpa, 1);
d.link_objects.appendAssumeCapacity(try d.comp.gpa.dupe(u8, out_file_name));
d.temp_file_count += 1;
if (fast_exit) {
try d.invokeLinker(tc, fast_exit);
}
}
fn dumpLinkerArgs(items: []const []const u8) !void {
const stdout = std.io.getStdOut().writer();
for (items, 0..) |item, i| {
if (i > 0) try stdout.writeByte(' ');
try stdout.print("\"{}\"", .{std.zig.fmtEscapes(item)});
}
try stdout.writeByte('\n');
}
/// The entry point of the Aro compiler.
/// **MAY call `exit` if `fast_exit` is set.**
pub fn invokeLinker(d: *Driver, tc: *Toolchain, comptime fast_exit: bool) !void {
var argv = std.ArrayList([]const u8).init(d.comp.gpa);
defer argv.deinit();
var linker_path_buf: [std.fs.max_path_bytes]u8 = undefined;
const linker_path = try tc.getLinkerPath(&linker_path_buf);
try argv.append(linker_path);
try tc.buildLinkerArgs(&argv);
if (d.verbose_linker_args) {
dumpLinkerArgs(argv.items) catch |er| {
return d.fatal("unable to dump linker args: {s}", .{errorDescription(er)});
};
}
var child = std.process.Child.init(argv.items, d.comp.gpa);
// TODO handle better
child.stdin_behavior = .Inherit;
child.stdout_behavior = .Inherit;
child.stderr_behavior = .Inherit;
const term = child.spawnAndWait() catch |er| {
return d.fatal("unable to spawn linker: {s}", .{errorDescription(er)});
};
switch (term) {
.Exited => |code| if (code != 0) {
const e = d.fatal("linker exited with an error code", .{});
if (fast_exit) d.exitWithCleanup(code);
return e;
},
else => {
const e = d.fatal("linker crashed", .{});
if (fast_exit) d.exitWithCleanup(1);
return e;
},
}
if (fast_exit) d.exitWithCleanup(0);
}
fn exitWithCleanup(d: *Driver, code: u8) noreturn {
for (d.link_objects.items[d.link_objects.items.len - d.temp_file_count ..]) |obj| {
std.fs.deleteFileAbsolute(obj) catch {};
}
std.process.exit(code);
}
|
0 | repos/arocc/src | repos/arocc/src/aro/SymbolStack.zig | const std = @import("std");
const mem = std.mem;
const Allocator = mem.Allocator;
const assert = std.debug.assert;
const Tree = @import("Tree.zig");
const Token = Tree.Token;
const TokenIndex = Tree.TokenIndex;
const NodeIndex = Tree.NodeIndex;
const Type = @import("Type.zig");
const Parser = @import("Parser.zig");
const Value = @import("Value.zig");
const StringId = @import("StringInterner.zig").StringId;
const SymbolStack = @This();
pub const Symbol = struct {
name: StringId,
ty: Type,
tok: TokenIndex,
node: NodeIndex = .none,
kind: Kind,
val: Value,
};
pub const Kind = enum {
typedef,
@"struct",
@"union",
@"enum",
decl,
def,
enumeration,
constexpr,
};
scopes: std.ArrayListUnmanaged(Scope) = .{},
/// allocations from nested scopes are retained after popping; `active_len` is the number
/// of currently-active items in `scopes`.
active_len: usize = 0,
const Scope = struct {
vars: std.AutoHashMapUnmanaged(StringId, Symbol) = .{},
tags: std.AutoHashMapUnmanaged(StringId, Symbol) = .{},
fn deinit(self: *Scope, allocator: Allocator) void {
self.vars.deinit(allocator);
self.tags.deinit(allocator);
}
fn clearRetainingCapacity(self: *Scope) void {
self.vars.clearRetainingCapacity();
self.tags.clearRetainingCapacity();
}
};
pub fn deinit(s: *SymbolStack, gpa: Allocator) void {
std.debug.assert(s.active_len == 0); // all scopes should have been popped
for (s.scopes.items) |*scope| {
scope.deinit(gpa);
}
s.scopes.deinit(gpa);
s.* = undefined;
}
pub fn pushScope(s: *SymbolStack, p: *Parser) !void {
if (s.active_len + 1 > s.scopes.items.len) {
try s.scopes.append(p.gpa, .{});
s.active_len = s.scopes.items.len;
} else {
s.scopes.items[s.active_len].clearRetainingCapacity();
s.active_len += 1;
}
}
pub fn popScope(s: *SymbolStack) void {
s.active_len -= 1;
}
pub fn findTypedef(s: *SymbolStack, p: *Parser, name: StringId, name_tok: TokenIndex, no_type_yet: bool) !?Symbol {
const prev = s.lookup(name, .vars) orelse s.lookup(name, .tags) orelse return null;
switch (prev.kind) {
.typedef => return prev,
.@"struct" => {
if (no_type_yet) return null;
try p.errStr(.must_use_struct, name_tok, p.tokSlice(name_tok));
return prev;
},
.@"union" => {
if (no_type_yet) return null;
try p.errStr(.must_use_union, name_tok, p.tokSlice(name_tok));
return prev;
},
.@"enum" => {
if (no_type_yet) return null;
try p.errStr(.must_use_enum, name_tok, p.tokSlice(name_tok));
return prev;
},
else => return null,
}
}
pub fn findSymbol(s: *SymbolStack, name: StringId) ?Symbol {
return s.lookup(name, .vars);
}
pub fn findTag(
s: *SymbolStack,
p: *Parser,
name: StringId,
kind: Token.Id,
name_tok: TokenIndex,
next_tok_id: Token.Id,
) !?Symbol {
// `tag Name;` should always result in a new type if in a new scope.
const prev = (if (next_tok_id == .semicolon) s.get(name, .tags) else s.lookup(name, .tags)) orelse return null;
switch (prev.kind) {
.@"enum" => if (kind == .keyword_enum) return prev,
.@"struct" => if (kind == .keyword_struct) return prev,
.@"union" => if (kind == .keyword_union) return prev,
else => unreachable,
}
if (s.get(name, .tags) == null) return null;
try p.errStr(.wrong_tag, name_tok, p.tokSlice(name_tok));
try p.errTok(.previous_definition, prev.tok);
return null;
}
const ScopeKind = enum {
/// structs, enums, unions
tags,
/// everything else
vars,
};
/// Return the Symbol for `name` (or null if not found) in the innermost scope
pub fn get(s: *SymbolStack, name: StringId, kind: ScopeKind) ?Symbol {
return switch (kind) {
.vars => s.scopes.items[s.active_len - 1].vars.get(name),
.tags => s.scopes.items[s.active_len - 1].tags.get(name),
};
}
/// Return the Symbol for `name` (or null if not found) in the nearest active scope,
/// starting at the innermost.
fn lookup(s: *SymbolStack, name: StringId, kind: ScopeKind) ?Symbol {
var i = s.active_len;
while (i > 0) {
i -= 1;
switch (kind) {
.vars => if (s.scopes.items[i].vars.get(name)) |sym| return sym,
.tags => if (s.scopes.items[i].tags.get(name)) |sym| return sym,
}
}
return null;
}
/// Define a symbol in the innermost scope. Does not issue diagnostics or check correctness
/// with regard to the C standard.
pub fn define(s: *SymbolStack, allocator: Allocator, symbol: Symbol) !void {
switch (symbol.kind) {
.constexpr, .def, .decl, .enumeration, .typedef => {
try s.scopes.items[s.active_len - 1].vars.put(allocator, symbol.name, symbol);
},
.@"struct", .@"union", .@"enum" => {
try s.scopes.items[s.active_len - 1].tags.put(allocator, symbol.name, symbol);
},
}
}
pub fn defineTypedef(
s: *SymbolStack,
p: *Parser,
name: StringId,
ty: Type,
tok: TokenIndex,
node: NodeIndex,
) !void {
if (s.get(name, .vars)) |prev| {
switch (prev.kind) {
.typedef => {
if (!prev.ty.is(.invalid)) {
if (!ty.eql(prev.ty, p.comp, true)) {
try p.errStr(.redefinition_of_typedef, tok, try p.typePairStrExtra(ty, " vs ", prev.ty));
if (prev.tok != 0) try p.errTok(.previous_definition, prev.tok);
}
}
},
.enumeration, .decl, .def, .constexpr => {
try p.errStr(.redefinition_different_sym, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
},
else => unreachable,
}
}
try s.define(p.gpa, .{
.kind = .typedef,
.name = name,
.tok = tok,
.ty = ty,
.node = node,
.val = .{},
});
}
pub fn defineSymbol(
s: *SymbolStack,
p: *Parser,
name: StringId,
ty: Type,
tok: TokenIndex,
node: NodeIndex,
val: Value,
constexpr: bool,
) !void {
if (s.get(name, .vars)) |prev| {
switch (prev.kind) {
.enumeration => {
try p.errStr(.redefinition_different_sym, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
},
.decl => {
if (!ty.eql(prev.ty, p.comp, true)) {
try p.errStr(.redefinition_incompatible, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
}
},
.def, .constexpr => {
try p.errStr(.redefinition, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
},
.typedef => {
try p.errStr(.redefinition_different_sym, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
},
else => unreachable,
}
}
try s.define(p.gpa, .{
.kind = if (constexpr) .constexpr else .def,
.name = name,
.tok = tok,
.ty = ty,
.node = node,
.val = val,
});
}
/// Get a pointer to the named symbol in the innermost scope.
/// Asserts that a symbol with the name exists.
pub fn getPtr(s: *SymbolStack, name: StringId, kind: ScopeKind) *Symbol {
return switch (kind) {
.tags => s.scopes.items[s.active_len - 1].tags.getPtr(name).?,
.vars => s.scopes.items[s.active_len - 1].vars.getPtr(name).?,
};
}
pub fn declareSymbol(
s: *SymbolStack,
p: *Parser,
name: StringId,
ty: Type,
tok: TokenIndex,
node: NodeIndex,
) !void {
if (s.get(name, .vars)) |prev| {
switch (prev.kind) {
.enumeration => {
try p.errStr(.redefinition_different_sym, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
},
.decl => {
if (!ty.eql(prev.ty, p.comp, true)) {
try p.errStr(.redefinition_incompatible, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
}
},
.def, .constexpr => {
if (!ty.eql(prev.ty, p.comp, true)) {
try p.errStr(.redefinition_incompatible, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
} else {
return;
}
},
.typedef => {
try p.errStr(.redefinition_different_sym, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
},
else => unreachable,
}
}
try s.define(p.gpa, .{
.kind = .decl,
.name = name,
.tok = tok,
.ty = ty,
.node = node,
.val = .{},
});
}
pub fn defineParam(s: *SymbolStack, p: *Parser, name: StringId, ty: Type, tok: TokenIndex) !void {
if (s.get(name, .vars)) |prev| {
switch (prev.kind) {
.enumeration, .decl, .def, .constexpr => {
try p.errStr(.redefinition_of_parameter, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
},
.typedef => {
try p.errStr(.redefinition_different_sym, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
},
else => unreachable,
}
}
if (ty.is(.fp16) and !p.comp.hasHalfPrecisionFloatABI()) {
try p.errStr(.suggest_pointer_for_invalid_fp16, tok, "parameters");
}
try s.define(p.gpa, .{
.kind = .def,
.name = name,
.tok = tok,
.ty = ty,
.val = .{},
});
}
pub fn defineTag(
s: *SymbolStack,
p: *Parser,
name: StringId,
kind: Token.Id,
tok: TokenIndex,
) !?Symbol {
const prev = s.get(name, .tags) orelse return null;
switch (prev.kind) {
.@"enum" => {
if (kind == .keyword_enum) return prev;
try p.errStr(.wrong_tag, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
return null;
},
.@"struct" => {
if (kind == .keyword_struct) return prev;
try p.errStr(.wrong_tag, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
return null;
},
.@"union" => {
if (kind == .keyword_union) return prev;
try p.errStr(.wrong_tag, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
return null;
},
else => unreachable,
}
}
pub fn defineEnumeration(
s: *SymbolStack,
p: *Parser,
name: StringId,
ty: Type,
tok: TokenIndex,
val: Value,
) !void {
if (s.get(name, .vars)) |prev| {
switch (prev.kind) {
.enumeration => {
try p.errStr(.redefinition, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
return;
},
.decl, .def, .constexpr => {
try p.errStr(.redefinition_different_sym, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
return;
},
.typedef => {
try p.errStr(.redefinition_different_sym, tok, p.tokSlice(tok));
try p.errTok(.previous_definition, prev.tok);
},
else => unreachable,
}
}
try s.define(p.gpa, .{
.kind = .enumeration,
.name = name,
.tok = tok,
.ty = ty,
.val = val,
});
}
|
0 | repos/arocc/src | repos/arocc/src/aro/LangOpts.zig | const std = @import("std");
const DiagnosticTag = @import("Diagnostics.zig").Tag;
const char_info = @import("char_info.zig");
pub const Compiler = enum {
clang,
gcc,
msvc,
};
/// The floating-point evaluation method for intermediate results within a single expression
pub const FPEvalMethod = enum(i8) {
/// The evaluation method cannot be determined or is inconsistent for this target.
indeterminate = -1,
/// Use the type declared in the source
source = 0,
/// Use double as the floating-point evaluation method for all float expressions narrower than double.
double = 1,
/// Use long double as the floating-point evaluation method for all float expressions narrower than long double.
extended = 2,
};
pub const Standard = enum {
/// ISO C 1990
c89,
/// ISO C 1990 with amendment 1
iso9899,
/// ISO C 1990 with GNU extensions
gnu89,
/// ISO C 1999
c99,
/// ISO C 1999 with GNU extensions
gnu99,
/// ISO C 2011
c11,
/// ISO C 2011 with GNU extensions
gnu11,
/// ISO C 2017
c17,
/// Default value if nothing specified; adds the GNU keywords to
/// C17 but does not suppress warnings about using GNU extensions
default,
/// ISO C 2017 with GNU extensions
gnu17,
/// Working Draft for ISO C23
c23,
/// Working Draft for ISO C23 with GNU extensions
gnu23,
const NameMap = std.StaticStringMap(Standard).initComptime(.{
.{ "c89", .c89 }, .{ "c90", .c89 }, .{ "iso9899:1990", .c89 },
.{ "iso9899:199409", .iso9899 }, .{ "gnu89", .gnu89 }, .{ "gnu90", .gnu89 },
.{ "c99", .c99 }, .{ "iso9899:1999", .c99 }, .{ "c9x", .c99 },
.{ "iso9899:199x", .c99 }, .{ "gnu99", .gnu99 }, .{ "gnu9x", .gnu99 },
.{ "c11", .c11 }, .{ "iso9899:2011", .c11 }, .{ "c1x", .c11 },
.{ "iso9899:201x", .c11 }, .{ "gnu11", .gnu11 }, .{ "c17", .c17 },
.{ "iso9899:2017", .c17 }, .{ "c18", .c17 }, .{ "iso9899:2018", .c17 },
.{ "gnu17", .gnu17 }, .{ "gnu18", .gnu17 }, .{ "c23", .c23 },
.{ "gnu23", .gnu23 }, .{ "c2x", .c23 }, .{ "gnu2x", .gnu23 },
});
pub fn atLeast(self: Standard, other: Standard) bool {
return @intFromEnum(self) >= @intFromEnum(other);
}
pub fn isGNU(standard: Standard) bool {
return switch (standard) {
.gnu89, .gnu99, .gnu11, .default, .gnu17, .gnu23 => true,
else => false,
};
}
pub fn isExplicitGNU(standard: Standard) bool {
return standard.isGNU() and standard != .default;
}
/// Value reported by __STDC_VERSION__ macro
pub fn StdCVersionMacro(standard: Standard) ?[]const u8 {
return switch (standard) {
.c89, .gnu89 => null,
.iso9899 => "199409L",
.c99, .gnu99 => "199901L",
.c11, .gnu11 => "201112L",
.default, .c17, .gnu17 => "201710L",
.c23, .gnu23 => "202311L",
};
}
pub fn codepointAllowedInIdentifier(standard: Standard, codepoint: u21, is_start: bool) bool {
if (is_start) {
return if (standard.atLeast(.c23))
char_info.isXidStart(codepoint)
else if (standard.atLeast(.c11))
char_info.isC11IdChar(codepoint) and !char_info.isC11DisallowedInitialIdChar(codepoint)
else
char_info.isC99IdChar(codepoint) and !char_info.isC99DisallowedInitialIDChar(codepoint);
} else {
return if (standard.atLeast(.c23))
char_info.isXidContinue(codepoint)
else if (standard.atLeast(.c11))
char_info.isC11IdChar(codepoint)
else
char_info.isC99IdChar(codepoint);
}
}
};
const LangOpts = @This();
emulate: Compiler = .clang,
standard: Standard = .default,
/// -fshort-enums option, makes enums only take up as much space as they need to hold all the values.
short_enums: bool = false,
dollars_in_identifiers: bool = true,
declspec_attrs: bool = false,
ms_extensions: bool = false,
/// true or false if digraph support explicitly enabled/disabled with -fdigraphs/-fno-digraphs
digraphs: ?bool = null,
/// If set, use the native half type instead of promoting to float
use_native_half_type: bool = false,
/// If set, function arguments and return values may be of type __fp16 even if there is no standard ABI for it
allow_half_args_and_returns: bool = false,
/// null indicates that the user did not select a value, use target to determine default
fp_eval_method: ?FPEvalMethod = null,
/// If set, use specified signedness for `char` instead of the target's default char signedness
char_signedness_override: ?std.builtin.Signedness = null,
/// If set, override the default availability of char8_t (by default, enabled in C23 and later; disabled otherwise)
has_char8_t_override: ?bool = null,
/// Whether to allow GNU-style inline assembly
gnu_asm: bool = true,
/// Preserve comments when preprocessing
preserve_comments: bool = false,
/// Preserve comments in macros when preprocessing
preserve_comments_in_macros: bool = false,
/// Used ONLY for generating __GNUC__ and related macros. Does not control the presence/absence of any features
/// Encoded as major * 10,000 + minor * 100 + patch
/// e.g. 4.2.1 == 40201
gnuc_version: u32 = 0,
pub fn setStandard(self: *LangOpts, name: []const u8) error{InvalidStandard}!void {
self.standard = Standard.NameMap.get(name) orelse return error.InvalidStandard;
}
pub fn enableMSExtensions(self: *LangOpts) void {
self.declspec_attrs = true;
self.ms_extensions = true;
}
pub fn disableMSExtensions(self: *LangOpts) void {
self.declspec_attrs = false;
self.ms_extensions = true;
}
pub fn hasChar8_T(self: *const LangOpts) bool {
return self.has_char8_t_override orelse self.standard.atLeast(.c23);
}
pub fn hasDigraphs(self: *const LangOpts) bool {
return self.digraphs orelse self.standard.atLeast(.gnu89);
}
pub fn setEmulatedCompiler(self: *LangOpts, compiler: Compiler) void {
self.emulate = compiler;
if (compiler == .msvc) self.enableMSExtensions();
}
pub fn setFpEvalMethod(self: *LangOpts, fp_eval_method: FPEvalMethod) void {
self.fp_eval_method = fp_eval_method;
}
pub fn setCharSignedness(self: *LangOpts, signedness: std.builtin.Signedness) void {
self.char_signedness_override = signedness;
}
|
0 | repos/arocc/src | repos/arocc/src/aro/char_info.zig | //! This module provides functions for classifying characters according to
//! various C standards. All classification routines *do not* consider
//! characters from the basic character set; it is assumed those will be
//! checked separately
//! isXidStart and isXidContinue are adapted from https://github.com/dtolnay/unicode-ident
const assert = @import("std").debug.assert;
const tables = @import("char_info/identifier_tables.zig");
/// C11 Standard Annex D
pub fn isC11IdChar(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
// 1
0x00A8,
0x00AA,
0x00AD,
0x00AF,
0x00B2...0x00B5,
0x00B7...0x00BA,
0x00BC...0x00BE,
0x00C0...0x00D6,
0x00D8...0x00F6,
0x00F8...0x00FF,
// 2
0x0100...0x167F,
0x1681...0x180D,
0x180F...0x1FFF,
// 3
0x200B...0x200D,
0x202A...0x202E,
0x203F...0x2040,
0x2054,
0x2060...0x206F,
// 4
0x2070...0x218F,
0x2460...0x24FF,
0x2776...0x2793,
0x2C00...0x2DFF,
0x2E80...0x2FFF,
// 5
0x3004...0x3007,
0x3021...0x302F,
0x3031...0x303F,
// 6
0x3040...0xD7FF,
// 7
0xF900...0xFD3D,
0xFD40...0xFDCF,
0xFDF0...0xFE44,
0xFE47...0xFFFD,
// 8
0x10000...0x1FFFD,
0x20000...0x2FFFD,
0x30000...0x3FFFD,
0x40000...0x4FFFD,
0x50000...0x5FFFD,
0x60000...0x6FFFD,
0x70000...0x7FFFD,
0x80000...0x8FFFD,
0x90000...0x9FFFD,
0xA0000...0xAFFFD,
0xB0000...0xBFFFD,
0xC0000...0xCFFFD,
0xD0000...0xDFFFD,
0xE0000...0xEFFFD,
=> true,
else => false,
};
}
/// C99 Standard Annex D
pub fn isC99IdChar(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
// Latin
0x00AA,
0x00BA,
0x00C0...0x00D6,
0x00D8...0x00F6,
0x00F8...0x01F5,
0x01FA...0x0217,
0x0250...0x02A8,
0x1E00...0x1E9B,
0x1EA0...0x1EF9,
0x207F,
// Greek
0x0386,
0x0388...0x038A,
0x038C,
0x038E...0x03A1,
0x03A3...0x03CE,
0x03D0...0x03D6,
0x03DA,
0x03DC,
0x03DE,
0x03E0,
0x03E2...0x03F3,
0x1F00...0x1F15,
0x1F18...0x1F1D,
0x1F20...0x1F45,
0x1F48...0x1F4D,
0x1F50...0x1F57,
0x1F59,
0x1F5B,
0x1F5D,
0x1F5F...0x1F7D,
0x1F80...0x1FB4,
0x1FB6...0x1FBC,
0x1FC2...0x1FC4,
0x1FC6...0x1FCC,
0x1FD0...0x1FD3,
0x1FD6...0x1FDB,
0x1FE0...0x1FEC,
0x1FF2...0x1FF4,
0x1FF6...0x1FFC,
// Cyrillic
0x0401...0x040C,
0x040E...0x044F,
0x0451...0x045C,
0x045E...0x0481,
0x0490...0x04C4,
0x04C7...0x04C8,
0x04CB...0x04CC,
0x04D0...0x04EB,
0x04EE...0x04F5,
0x04F8...0x04F9,
// Armenian
0x0531...0x0556,
0x0561...0x0587,
// Hebrew
0x05B0...0x05B9,
0x05BB...0x05BD,
0x05BF,
0x05C1...0x05C2,
0x05D0...0x05EA,
0x05F0...0x05F2,
// Arabic
0x0621...0x063A,
0x0640...0x0652,
0x0670...0x06B7,
0x06BA...0x06BE,
0x06C0...0x06CE,
0x06D0...0x06DC,
0x06E5...0x06E8,
0x06EA...0x06ED,
// Devanagari
0x0901...0x0903,
0x0905...0x0939,
0x093E...0x094D,
0x0950...0x0952,
0x0958...0x0963,
// Bengali
0x0981...0x0983,
0x0985...0x098C,
0x098F...0x0990,
0x0993...0x09A8,
0x09AA...0x09B0,
0x09B2,
0x09B6...0x09B9,
0x09BE...0x09C4,
0x09C7...0x09C8,
0x09CB...0x09CD,
0x09DC...0x09DD,
0x09DF...0x09E3,
0x09F0...0x09F1,
// Gurmukhi
0x0A02,
0x0A05...0x0A0A,
0x0A0F...0x0A10,
0x0A13...0x0A28,
0x0A2A...0x0A30,
0x0A32...0x0A33,
0x0A35...0x0A36,
0x0A38...0x0A39,
0x0A3E...0x0A42,
0x0A47...0x0A48,
0x0A4B...0x0A4D,
0x0A59...0x0A5C,
0x0A5E,
0x0A74,
// Gujarati
0x0A81...0x0A83,
0x0A85...0x0A8B,
0x0A8D,
0x0A8F...0x0A91,
0x0A93...0x0AA8,
0x0AAA...0x0AB0,
0x0AB2...0x0AB3,
0x0AB5...0x0AB9,
0x0ABD...0x0AC5,
0x0AC7...0x0AC9,
0x0ACB...0x0ACD,
0x0AD0,
0x0AE0,
// Oriya
0x0B01...0x0B03,
0x0B05...0x0B0C,
0x0B0F...0x0B10,
0x0B13...0x0B28,
0x0B2A...0x0B30,
0x0B32...0x0B33,
0x0B36...0x0B39,
0x0B3E...0x0B43,
0x0B47...0x0B48,
0x0B4B...0x0B4D,
0x0B5C...0x0B5D,
0x0B5F...0x0B61,
// Tamil
0x0B82...0x0B83,
0x0B85...0x0B8A,
0x0B8E...0x0B90,
0x0B92...0x0B95,
0x0B99...0x0B9A,
0x0B9C,
0x0B9E...0x0B9F,
0x0BA3...0x0BA4,
0x0BA8...0x0BAA,
0x0BAE...0x0BB5,
0x0BB7...0x0BB9,
0x0BBE...0x0BC2,
0x0BC6...0x0BC8,
0x0BCA...0x0BCD,
// Telugu
0x0C01...0x0C03,
0x0C05...0x0C0C,
0x0C0E...0x0C10,
0x0C12...0x0C28,
0x0C2A...0x0C33,
0x0C35...0x0C39,
0x0C3E...0x0C44,
0x0C46...0x0C48,
0x0C4A...0x0C4D,
0x0C60...0x0C61,
// Kannada
0x0C82...0x0C83,
0x0C85...0x0C8C,
0x0C8E...0x0C90,
0x0C92...0x0CA8,
0x0CAA...0x0CB3,
0x0CB5...0x0CB9,
0x0CBE...0x0CC4,
0x0CC6...0x0CC8,
0x0CCA...0x0CCD,
0x0CDE,
0x0CE0...0x0CE1,
// Malayalam
0x0D02...0x0D03,
0x0D05...0x0D0C,
0x0D0E...0x0D10,
0x0D12...0x0D28,
0x0D2A...0x0D39,
0x0D3E...0x0D43,
0x0D46...0x0D48,
0x0D4A...0x0D4D,
0x0D60...0x0D61,
// Thai (excluding digits 0x0E50...0x0E59; originally 0x0E01...0x0E3A and 0x0E40...0x0E5B
0x0E01...0x0E3A,
0x0E40...0x0E4F,
0x0E5A...0x0E5B,
// Lao
0x0E81...0x0E82,
0x0E84,
0x0E87...0x0E88,
0x0E8A,
0x0E8D,
0x0E94...0x0E97,
0x0E99...0x0E9F,
0x0EA1...0x0EA3,
0x0EA5,
0x0EA7,
0x0EAA...0x0EAB,
0x0EAD...0x0EAE,
0x0EB0...0x0EB9,
0x0EBB...0x0EBD,
0x0EC0...0x0EC4,
0x0EC6,
0x0EC8...0x0ECD,
0x0EDC...0x0EDD,
// Tibetan
0x0F00,
0x0F18...0x0F19,
0x0F35,
0x0F37,
0x0F39,
0x0F3E...0x0F47,
0x0F49...0x0F69,
0x0F71...0x0F84,
0x0F86...0x0F8B,
0x0F90...0x0F95,
0x0F97,
0x0F99...0x0FAD,
0x0FB1...0x0FB7,
0x0FB9,
// Georgian
0x10A0...0x10C5,
0x10D0...0x10F6,
// Hiragana
0x3041...0x3093,
0x309B...0x309C,
// Katakana
0x30A1...0x30F6,
0x30FB...0x30FC,
// Bopomofo
0x3105...0x312C,
// CJK Unified Ideographs
0x4E00...0x9FA5,
// Hangul
0xAC00...0xD7A3,
// Digits
0x0660...0x0669,
0x06F0...0x06F9,
0x0966...0x096F,
0x09E6...0x09EF,
0x0A66...0x0A6F,
0x0AE6...0x0AEF,
0x0B66...0x0B6F,
0x0BE7...0x0BEF,
0x0C66...0x0C6F,
0x0CE6...0x0CEF,
0x0D66...0x0D6F,
0x0E50...0x0E59,
0x0ED0...0x0ED9,
0x0F20...0x0F33,
// Special characters
0x00B5,
0x00B7,
0x02B0...0x02B8,
0x02BB,
0x02BD...0x02C1,
0x02D0...0x02D1,
0x02E0...0x02E4,
0x037A,
0x0559,
0x093D,
0x0B3D,
0x1FBE,
0x203F...0x2040,
0x2102,
0x2107,
0x210A...0x2113,
0x2115,
0x2118...0x211D,
0x2124,
0x2126,
0x2128,
0x212A...0x2131,
0x2133...0x2138,
0x2160...0x2182,
0x3005...0x3007,
0x3021...0x3029,
=> true,
else => false,
};
}
/// C11 standard Annex D
pub fn isC11DisallowedInitialIdChar(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
0x0300...0x036F,
0x1DC0...0x1DFF,
0x20D0...0x20FF,
0xFE20...0xFE2F,
=> true,
else => false,
};
}
/// These are "digit" characters; C99 disallows them as the first
/// character of an identifier
pub fn isC99DisallowedInitialIDChar(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
0x0660...0x0669,
0x06F0...0x06F9,
0x0966...0x096F,
0x09E6...0x09EF,
0x0A66...0x0A6F,
0x0AE6...0x0AEF,
0x0B66...0x0B6F,
0x0BE7...0x0BEF,
0x0C66...0x0C6F,
0x0CE6...0x0CEF,
0x0D66...0x0D6F,
0x0E50...0x0E59,
0x0ED0...0x0ED9,
0x0F20...0x0F33,
=> true,
else => false,
};
}
pub fn isInvisible(codepoint: u21) bool {
assert(codepoint > 0x7F);
return switch (codepoint) {
0x00ad, // SOFT HYPHEN
0x200b, // ZERO WIDTH SPACE
0x200c, // ZERO WIDTH NON-JOINER
0x200d, // ZERO WIDTH JOINER
0x2060, // WORD JOINER
0x2061, // FUNCTION APPLICATION
0x2062, // INVISIBLE TIMES
0x2063, // INVISIBLE SEPARATOR
0x2064, // INVISIBLE PLUS
0xfeff, // ZERO WIDTH NO-BREAK SPACE
=> true,
else => false,
};
}
/// Checks for identifier characters which resemble non-identifier characters
pub fn homoglyph(codepoint: u21) ?u21 {
assert(codepoint > 0x7F);
return switch (codepoint) {
0x01c3 => '!', // LATIN LETTER RETROFLEX CLICK
0x037e => ';', // GREEK QUESTION MARK
0x2212 => '-', // MINUS SIGN
0x2215 => '/', // DIVISION SLASH
0x2216 => '\\', // SET MINUS
0x2217 => '*', // ASTERISK OPERATOR
0x2223 => '|', // DIVIDES
0x2227 => '^', // LOGICAL AND
0x2236 => ':', // RATIO
0x223c => '~', // TILDE OPERATOR
0xa789 => ':', // MODIFIER LETTER COLON
0xff01 => '!', // FULLWIDTH EXCLAMATION MARK
0xff03 => '#', // FULLWIDTH NUMBER SIGN
0xff04 => '$', // FULLWIDTH DOLLAR SIGN
0xff05 => '%', // FULLWIDTH PERCENT SIGN
0xff06 => '&', // FULLWIDTH AMPERSAND
0xff08 => '(', // FULLWIDTH LEFT PARENTHESIS
0xff09 => ')', // FULLWIDTH RIGHT PARENTHESIS
0xff0a => '*', // FULLWIDTH ASTERISK
0xff0b => '+', // FULLWIDTH ASTERISK
0xff0c => ',', // FULLWIDTH COMMA
0xff0d => '-', // FULLWIDTH HYPHEN-MINUS
0xff0e => '.', // FULLWIDTH FULL STOP
0xff0f => '/', // FULLWIDTH SOLIDUS
0xff1a => ':', // FULLWIDTH COLON
0xff1b => ';', // FULLWIDTH SEMICOLON
0xff1c => '<', // FULLWIDTH LESS-THAN SIGN
0xff1d => '=', // FULLWIDTH EQUALS SIGN
0xff1e => '>', // FULLWIDTH GREATER-THAN SIGN
0xff1f => '?', // FULLWIDTH QUESTION MARK
0xff20 => '@', // FULLWIDTH COMMERCIAL AT
0xff3b => '[', // FULLWIDTH LEFT SQUARE BRACKET
0xff3c => '\\', // FULLWIDTH REVERSE SOLIDUS
0xff3d => ']', // FULLWIDTH RIGHT SQUARE BRACKET
0xff3e => '^', // FULLWIDTH CIRCUMFLEX ACCENT
0xff5b => '{', // FULLWIDTH LEFT CURLY BRACKET
0xff5c => '|', // FULLWIDTH VERTICAL LINE
0xff5d => '}', // FULLWIDTH RIGHT CURLY BRACKET
0xff5e => '~', // FULLWIDTH TILDE
else => null,
};
}
pub fn isXidStart(c: u21) bool {
assert(c > 0x7F);
const idx = c / 8 / tables.chunk;
const chunk: usize = if (idx < tables.trie_start.len) tables.trie_start[idx] else 0;
const offset = chunk * tables.chunk / 2 + c / 8 % tables.chunk;
return (tables.leaf[offset] >> (@as(u3, @intCast(c % 8)))) & 1 != 0;
}
pub fn isXidContinue(c: u21) bool {
assert(c > 0x7F);
const idx = c / 8 / tables.chunk;
const chunk: usize = if (idx < tables.trie_continue.len) tables.trie_continue[idx] else 0;
const offset = chunk * tables.chunk / 2 + c / 8 % tables.chunk;
return (tables.leaf[offset] >> (@as(u3, @intCast(c % 8)))) & 1 != 0;
}
test "isXidStart / isXidContinue panic check" {
const std = @import("std");
for (0x80..0x110000) |i| {
const c: u21 = @intCast(i);
if (std.unicode.utf8ValidCodepoint(c)) {
_ = isXidStart(c);
_ = isXidContinue(c);
}
}
}
test isXidStart {
const std = @import("std");
try std.testing.expect(!isXidStart('᠑'));
try std.testing.expect(!isXidStart('™'));
try std.testing.expect(!isXidStart('£'));
try std.testing.expect(!isXidStart('\u{1f914}')); // 🤔
}
test isXidContinue {
const std = @import("std");
try std.testing.expect(isXidContinue('᠑'));
try std.testing.expect(!isXidContinue('™'));
try std.testing.expect(!isXidContinue('£'));
try std.testing.expect(!isXidContinue('\u{1f914}')); // 🤔
}
pub const NfcQuickCheck = enum { no, maybe, yes };
pub fn isNormalized(codepoint: u21) NfcQuickCheck {
return switch (codepoint) {
0x0340...0x0341,
0x0343...0x0344,
0x0374,
0x037E,
0x0387,
0x0958...0x095F,
0x09DC...0x09DD,
0x09DF,
0x0A33,
0x0A36,
0x0A59...0x0A5B,
0x0A5E,
0x0B5C...0x0B5D,
0x0F43,
0x0F4D,
0x0F52,
0x0F57,
0x0F5C,
0x0F69,
0x0F73,
0x0F75...0x0F76,
0x0F78,
0x0F81,
0x0F93,
0x0F9D,
0x0FA2,
0x0FA7,
0x0FAC,
0x0FB9,
0x1F71,
0x1F73,
0x1F75,
0x1F77,
0x1F79,
0x1F7B,
0x1F7D,
0x1FBB,
0x1FBE,
0x1FC9,
0x1FCB,
0x1FD3,
0x1FDB,
0x1FE3,
0x1FEB,
0x1FEE...0x1FEF,
0x1FF9,
0x1FFB,
0x1FFD,
0x2000...0x2001,
0x2126,
0x212A...0x212B,
0x2329,
0x232A,
0x2ADC,
0xF900...0xFA0D,
0xFA10,
0xFA12,
0xFA15...0xFA1E,
0xFA20,
0xFA22,
0xFA25...0xFA26,
0xFA2A...0xFA6D,
0xFA70...0xFAD9,
0xFB1D,
0xFB1F,
0xFB2A...0xFB36,
0xFB38...0xFB3C,
0xFB3E,
0xFB40...0xFB41,
0xFB43...0xFB44,
0xFB46...0xFB4E,
0x1D15E...0x1D164,
0x1D1BB...0x1D1C0,
0x2F800...0x2FA1D,
=> .no,
0x0300...0x0304,
0x0306...0x030C,
0x030F,
0x0311,
0x0313...0x0314,
0x031B,
0x0323...0x0328,
0x032D...0x032E,
0x0330...0x0331,
0x0338,
0x0342,
0x0345,
0x0653...0x0655,
0x093C,
0x09BE,
0x09D7,
0x0B3E,
0x0B56,
0x0B57,
0x0BBE,
0x0BD7,
0x0C56,
0x0CC2,
0x0CD5...0x0CD6,
0x0D3E,
0x0D57,
0x0DCA,
0x0DCF,
0x0DDF,
0x102E,
0x1161...0x1175,
0x11A8...0x11C2,
0x1B35,
0x3099...0x309A,
0x110BA,
0x11127,
0x1133E,
0x11357,
0x114B0,
0x114BA,
0x114BD,
0x115AF,
=> .maybe,
else => .yes,
};
}
pub const CanonicalCombiningClass = enum(u8) {
not_reordered = 0,
overlay = 1,
han_reading = 6,
nukta = 7,
kana_voicing = 8,
virama = 9,
ccc10 = 10,
ccc11 = 11,
ccc12 = 12,
ccc13 = 13,
ccc14 = 14,
ccc15 = 15,
ccc16 = 16,
ccc17 = 17,
ccc18 = 18,
ccc19 = 19,
ccc20 = 20,
ccc21 = 21,
ccc22 = 22,
ccc23 = 23,
ccc24 = 24,
ccc25 = 25,
ccc26 = 26,
ccc27 = 27,
ccc28 = 28,
ccc29 = 29,
ccc30 = 30,
ccc31 = 31,
ccc32 = 32,
ccc33 = 33,
ccc34 = 34,
ccc35 = 35,
ccc36 = 36,
ccc84 = 84,
ccc91 = 91,
ccc103 = 103,
ccc107 = 107,
ccc118 = 118,
ccc122 = 122,
ccc129 = 129,
ccc130 = 130,
ccc132 = 132,
attached_below = 202,
attached_above = 214,
attached_above_right = 216,
below_left = 218,
below = 220,
below_right = 222,
left = 224,
right = 226,
above_left = 228,
above = 230,
above_right = 232,
double_below = 233,
double_above = 234,
iota_subscript = 240,
};
pub fn getCanonicalClass(codepoint: u21) CanonicalCombiningClass {
return switch (codepoint) {
0x300...0x314 => .above,
0x315...0x315 => .above_right,
0x316...0x319 => .below,
0x31A...0x31A => .above_right,
0x31B...0x31B => .attached_above_right,
0x31C...0x320 => .below,
0x321...0x322 => .attached_below,
0x323...0x326 => .below,
0x327...0x328 => .attached_below,
0x329...0x333 => .below,
0x334...0x338 => .overlay,
0x339...0x33C => .below,
0x33D...0x344 => .above,
0x345...0x345 => .iota_subscript,
0x346...0x346 => .above,
0x347...0x349 => .below,
0x34A...0x34C => .above,
0x34D...0x34E => .below,
0x350...0x352 => .above,
0x353...0x356 => .below,
0x357...0x357 => .above,
0x358...0x358 => .above_right,
0x359...0x35A => .below,
0x35B...0x35B => .above,
0x35C...0x35C => .double_below,
0x35D...0x35E => .double_above,
0x35F...0x35F => .double_below,
0x360...0x361 => .double_above,
0x362...0x362 => .double_below,
0x363...0x36F => .above,
0x483...0x487 => .above,
0x591...0x591 => .below,
0x592...0x595 => .above,
0x596...0x596 => .below,
0x597...0x599 => .above,
0x59A...0x59A => .below_right,
0x59B...0x59B => .below,
0x59C...0x5A1 => .above,
0x5A2...0x5A7 => .below,
0x5A8...0x5A9 => .above,
0x5AA...0x5AA => .below,
0x5AB...0x5AC => .above,
0x5AD...0x5AD => .below_right,
0x5AE...0x5AE => .above_left,
0x5AF...0x5AF => .above,
0x5B0...0x5B0 => .ccc10,
0x5B1...0x5B1 => .ccc11,
0x5B2...0x5B2 => .ccc12,
0x5B3...0x5B3 => .ccc13,
0x5B4...0x5B4 => .ccc14,
0x5B5...0x5B5 => .ccc15,
0x5B6...0x5B6 => .ccc16,
0x5B7...0x5B7 => .ccc17,
0x5B8...0x5B8 => .ccc18,
0x5B9...0x5BA => .ccc19,
0x5BB...0x5BB => .ccc20,
0x5BC...0x5BC => .ccc21,
0x5BD...0x5BD => .ccc22,
0x5BF...0x5BF => .ccc23,
0x5C1...0x5C1 => .ccc24,
0x5C2...0x5C2 => .ccc25,
0x5C4...0x5C4 => .above,
0x5C5...0x5C5 => .below,
0x5C7...0x5C7 => .ccc18,
0x610...0x617 => .above,
0x618...0x618 => .ccc30,
0x619...0x619 => .ccc31,
0x61A...0x61A => .ccc32,
0x64B...0x64B => .ccc27,
0x64C...0x64C => .ccc28,
0x64D...0x64D => .ccc29,
0x64E...0x64E => .ccc30,
0x64F...0x64F => .ccc31,
0x650...0x650 => .ccc32,
0x651...0x651 => .ccc33,
0x652...0x652 => .ccc34,
0x653...0x654 => .above,
0x655...0x656 => .below,
0x657...0x65B => .above,
0x65C...0x65C => .below,
0x65D...0x65E => .above,
0x65F...0x65F => .below,
0x670...0x670 => .ccc35,
0x6D6...0x6DC => .above,
0x6DF...0x6E2 => .above,
0x6E3...0x6E3 => .below,
0x6E4...0x6E4 => .above,
0x6E7...0x6E8 => .above,
0x6EA...0x6EA => .below,
0x6EB...0x6EC => .above,
0x6ED...0x6ED => .below,
0x711...0x711 => .ccc36,
0x730...0x730 => .above,
0x731...0x731 => .below,
0x732...0x733 => .above,
0x734...0x734 => .below,
0x735...0x736 => .above,
0x737...0x739 => .below,
0x73A...0x73A => .above,
0x73B...0x73C => .below,
0x73D...0x73D => .above,
0x73E...0x73E => .below,
0x73F...0x741 => .above,
0x742...0x742 => .below,
0x743...0x743 => .above,
0x744...0x744 => .below,
0x745...0x745 => .above,
0x746...0x746 => .below,
0x747...0x747 => .above,
0x748...0x748 => .below,
0x749...0x74A => .above,
0x7EB...0x7F1 => .above,
0x7F2...0x7F2 => .below,
0x7F3...0x7F3 => .above,
0x7FD...0x7FD => .below,
0x816...0x819 => .above,
0x81B...0x823 => .above,
0x825...0x827 => .above,
0x829...0x82D => .above,
0x859...0x85B => .below,
0x898...0x898 => .above,
0x899...0x89B => .below,
0x89C...0x89F => .above,
0x8CA...0x8CE => .above,
0x8CF...0x8D3 => .below,
0x8D4...0x8E1 => .above,
0x8E3...0x8E3 => .below,
0x8E4...0x8E5 => .above,
0x8E6...0x8E6 => .below,
0x8E7...0x8E8 => .above,
0x8E9...0x8E9 => .below,
0x8EA...0x8EC => .above,
0x8ED...0x8EF => .below,
0x8F0...0x8F0 => .ccc27,
0x8F1...0x8F1 => .ccc28,
0x8F2...0x8F2 => .ccc29,
0x8F3...0x8F5 => .above,
0x8F6...0x8F6 => .below,
0x8F7...0x8F8 => .above,
0x8F9...0x8FA => .below,
0x8FB...0x8FF => .above,
0x93C...0x93C => .nukta,
0x94D...0x94D => .virama,
0x951...0x951 => .above,
0x952...0x952 => .below,
0x953...0x954 => .above,
0x9BC...0x9BC => .nukta,
0x9CD...0x9CD => .virama,
0x9FE...0x9FE => .above,
0xA3C...0xA3C => .nukta,
0xA4D...0xA4D => .virama,
0xABC...0xABC => .nukta,
0xACD...0xACD => .virama,
0xB3C...0xB3C => .nukta,
0xB4D...0xB4D => .virama,
0xBCD...0xBCD => .virama,
0xC3C...0xC3C => .nukta,
0xC4D...0xC4D => .virama,
0xC55...0xC55 => .ccc84,
0xC56...0xC56 => .ccc91,
0xCBC...0xCBC => .nukta,
0xCCD...0xCCD => .virama,
0xD3B...0xD3C => .virama,
0xD4D...0xD4D => .virama,
0xDCA...0xDCA => .virama,
0xE38...0xE39 => .ccc103,
0xE3A...0xE3A => .virama,
0xE48...0xE4B => .ccc107,
0xEB8...0xEB9 => .ccc118,
0xEBA...0xEBA => .virama,
0xEC8...0xECB => .ccc122,
0xF18...0xF19 => .below,
0xF35...0xF35 => .below,
0xF37...0xF37 => .below,
0xF39...0xF39 => .attached_above_right,
0xF71...0xF71 => .ccc129,
0xF72...0xF72 => .ccc130,
0xF74...0xF74 => .ccc132,
0xF7A...0xF7D => .ccc130,
0xF80...0xF80 => .ccc130,
0xF82...0xF83 => .above,
0xF84...0xF84 => .virama,
0xF86...0xF87 => .above,
0xFC6...0xFC6 => .below,
0x1037...0x1037 => .nukta,
0x1039...0x103A => .virama,
0x108D...0x108D => .below,
0x135D...0x135F => .above,
0x1714...0x1715 => .virama,
0x1734...0x1734 => .virama,
0x17D2...0x17D2 => .virama,
0x17DD...0x17DD => .above,
0x18A9...0x18A9 => .above_left,
0x1939...0x1939 => .below_right,
0x193A...0x193A => .above,
0x193B...0x193B => .below,
0x1A17...0x1A17 => .above,
0x1A18...0x1A18 => .below,
0x1A60...0x1A60 => .virama,
0x1A75...0x1A7C => .above,
0x1A7F...0x1A7F => .below,
0x1AB0...0x1AB4 => .above,
0x1AB5...0x1ABA => .below,
0x1ABB...0x1ABC => .above,
0x1ABD...0x1ABD => .below,
0x1ABF...0x1AC0 => .below,
0x1AC1...0x1AC2 => .above,
0x1AC3...0x1AC4 => .below,
0x1AC5...0x1AC9 => .above,
0x1ACA...0x1ACA => .below,
0x1ACB...0x1ACE => .above,
0x1B34...0x1B34 => .nukta,
0x1B44...0x1B44 => .virama,
0x1B6B...0x1B6B => .above,
0x1B6C...0x1B6C => .below,
0x1B6D...0x1B73 => .above,
0x1BAA...0x1BAB => .virama,
0x1BE6...0x1BE6 => .nukta,
0x1BF2...0x1BF3 => .virama,
0x1C37...0x1C37 => .nukta,
0x1CD0...0x1CD2 => .above,
0x1CD4...0x1CD4 => .overlay,
0x1CD5...0x1CD9 => .below,
0x1CDA...0x1CDB => .above,
0x1CDC...0x1CDF => .below,
0x1CE0...0x1CE0 => .above,
0x1CE2...0x1CE8 => .overlay,
0x1CED...0x1CED => .below,
0x1CF4...0x1CF4 => .above,
0x1CF8...0x1CF9 => .above,
0x1DC0...0x1DC1 => .above,
0x1DC2...0x1DC2 => .below,
0x1DC3...0x1DC9 => .above,
0x1DCA...0x1DCA => .below,
0x1DCB...0x1DCC => .above,
0x1DCD...0x1DCD => .double_above,
0x1DCE...0x1DCE => .attached_above,
0x1DCF...0x1DCF => .below,
0x1DD0...0x1DD0 => .attached_below,
0x1DD1...0x1DF5 => .above,
0x1DF6...0x1DF6 => .above_right,
0x1DF7...0x1DF8 => .above_left,
0x1DF9...0x1DF9 => .below,
0x1DFA...0x1DFA => .below_left,
0x1DFB...0x1DFB => .above,
0x1DFC...0x1DFC => .double_below,
0x1DFD...0x1DFD => .below,
0x1DFE...0x1DFE => .above,
0x1DFF...0x1DFF => .below,
0x20D0...0x20D1 => .above,
0x20D2...0x20D3 => .overlay,
0x20D4...0x20D7 => .above,
0x20D8...0x20DA => .overlay,
0x20DB...0x20DC => .above,
0x20E1...0x20E1 => .above,
0x20E5...0x20E6 => .overlay,
0x20E7...0x20E7 => .above,
0x20E8...0x20E8 => .below,
0x20E9...0x20E9 => .above,
0x20EA...0x20EB => .overlay,
0x20EC...0x20EF => .below,
0x20F0...0x20F0 => .above,
0x2CEF...0x2CF1 => .above,
0x2D7F...0x2D7F => .virama,
0x2DE0...0x2DFF => .above,
0x302A...0x302A => .below_left,
0x302B...0x302B => .above_left,
0x302C...0x302C => .above_right,
0x302D...0x302D => .below_right,
0x302E...0x302F => .left,
0x3099...0x309A => .kana_voicing,
0xA66F...0xA66F => .above,
0xA674...0xA67D => .above,
0xA69E...0xA69F => .above,
0xA6F0...0xA6F1 => .above,
0xA806...0xA806 => .virama,
0xA82C...0xA82C => .virama,
0xA8C4...0xA8C4 => .virama,
0xA8E0...0xA8F1 => .above,
0xA92B...0xA92D => .below,
0xA953...0xA953 => .virama,
0xA9B3...0xA9B3 => .nukta,
0xA9C0...0xA9C0 => .virama,
0xAAB0...0xAAB0 => .above,
0xAAB2...0xAAB3 => .above,
0xAAB4...0xAAB4 => .below,
0xAAB7...0xAAB8 => .above,
0xAABE...0xAABF => .above,
0xAAC1...0xAAC1 => .above,
0xAAF6...0xAAF6 => .virama,
0xABED...0xABED => .virama,
0xFB1E...0xFB1E => .ccc26,
0xFE20...0xFE26 => .above,
0xFE27...0xFE2D => .below,
0xFE2E...0xFE2F => .above,
0x101FD...0x101FD => .below,
0x102E0...0x102E0 => .below,
0x10376...0x1037A => .above,
0x10A0D...0x10A0D => .below,
0x10A0F...0x10A0F => .above,
0x10A38...0x10A38 => .above,
0x10A39...0x10A39 => .overlay,
0x10A3A...0x10A3A => .below,
0x10A3F...0x10A3F => .virama,
0x10AE5...0x10AE5 => .above,
0x10AE6...0x10AE6 => .below,
0x10D24...0x10D27 => .above,
0x10EAB...0x10EAC => .above,
0x10EFD...0x10EFF => .below,
0x10F46...0x10F47 => .below,
0x10F48...0x10F4A => .above,
0x10F4B...0x10F4B => .below,
0x10F4C...0x10F4C => .above,
0x10F4D...0x10F50 => .below,
0x10F82...0x10F82 => .above,
0x10F83...0x10F83 => .below,
0x10F84...0x10F84 => .above,
0x10F85...0x10F85 => .below,
0x11046...0x11046 => .virama,
0x11070...0x11070 => .virama,
0x1107F...0x1107F => .virama,
0x110B9...0x110B9 => .virama,
0x110BA...0x110BA => .nukta,
0x11100...0x11102 => .above,
0x11133...0x11134 => .virama,
0x11173...0x11173 => .nukta,
0x111C0...0x111C0 => .virama,
0x111CA...0x111CA => .nukta,
0x11235...0x11235 => .virama,
0x11236...0x11236 => .nukta,
0x112E9...0x112E9 => .nukta,
0x112EA...0x112EA => .virama,
0x1133B...0x1133C => .nukta,
0x1134D...0x1134D => .virama,
0x11366...0x1136C => .above,
0x11370...0x11374 => .above,
0x11442...0x11442 => .virama,
0x11446...0x11446 => .nukta,
0x1145E...0x1145E => .above,
0x114C2...0x114C2 => .virama,
0x114C3...0x114C3 => .nukta,
0x115BF...0x115BF => .virama,
0x115C0...0x115C0 => .nukta,
0x1163F...0x1163F => .virama,
0x116B6...0x116B6 => .virama,
0x116B7...0x116B7 => .nukta,
0x1172B...0x1172B => .virama,
0x11839...0x11839 => .virama,
0x1183A...0x1183A => .nukta,
0x1193D...0x1193E => .virama,
0x11943...0x11943 => .nukta,
0x119E0...0x119E0 => .virama,
0x11A34...0x11A34 => .virama,
0x11A47...0x11A47 => .virama,
0x11A99...0x11A99 => .virama,
0x11C3F...0x11C3F => .virama,
0x11D42...0x11D42 => .nukta,
0x11D44...0x11D45 => .virama,
0x11D97...0x11D97 => .virama,
0x11F41...0x11F42 => .virama,
0x16AF0...0x16AF4 => .overlay,
0x16B30...0x16B36 => .above,
0x16FF0...0x16FF1 => .han_reading,
0x1BC9E...0x1BC9E => .overlay,
0x1D165...0x1D166 => .attached_above_right,
0x1D167...0x1D169 => .overlay,
0x1D16D...0x1D16D => .right,
0x1D16E...0x1D172 => .attached_above_right,
0x1D17B...0x1D182 => .below,
0x1D185...0x1D189 => .above,
0x1D18A...0x1D18B => .below,
0x1D1AA...0x1D1AD => .above,
0x1D242...0x1D244 => .above,
0x1E000...0x1E006 => .above,
0x1E008...0x1E018 => .above,
0x1E01B...0x1E021 => .above,
0x1E023...0x1E024 => .above,
0x1E026...0x1E02A => .above,
0x1E08F...0x1E08F => .above,
0x1E130...0x1E136 => .above,
0x1E2AE...0x1E2AE => .above,
0x1E2EC...0x1E2EF => .above,
0x1E4EC...0x1E4ED => .above_right,
0x1E4EE...0x1E4EE => .below,
0x1E4EF...0x1E4EF => .above,
0x1E8D0...0x1E8D6 => .below,
0x1E944...0x1E949 => .above,
0x1E94A...0x1E94A => .nukta,
else => .not_reordered,
};
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Tree/number_affixes.zig | const std = @import("std");
const mem = std.mem;
pub const Prefix = enum(u8) {
binary = 2,
octal = 8,
decimal = 10,
hex = 16,
pub fn digitAllowed(prefix: Prefix, c: u8) bool {
return switch (c) {
'0', '1' => true,
'2'...'7' => prefix != .binary,
'8'...'9' => prefix == .decimal or prefix == .hex,
'a'...'f', 'A'...'F' => prefix == .hex,
else => false,
};
}
pub fn fromString(buf: []const u8) Prefix {
if (buf.len == 1) return .decimal;
// tokenizer enforces that first byte is a decimal digit or period
switch (buf[0]) {
'.', '1'...'9' => return .decimal,
'0' => {},
else => unreachable,
}
switch (buf[1]) {
'x', 'X' => return if (buf.len == 2) .decimal else .hex,
'b', 'B' => return if (buf.len == 2) .decimal else .binary,
else => {
if (mem.indexOfAny(u8, buf, "eE.")) |_| {
// This is a decimal floating point number that happens to start with zero
return .decimal;
} else if (Suffix.fromString(buf[1..], .int)) |_| {
// This is `0` with a valid suffix
return .decimal;
} else {
return .octal;
}
},
}
}
/// Length of this prefix as a string
pub fn stringLen(prefix: Prefix) usize {
return switch (prefix) {
.binary => 2,
.octal => 1,
.decimal => 0,
.hex => 2,
};
}
};
pub const Suffix = enum {
// zig fmt: off
// int and imaginary int
None, I,
// unsigned real integers
U, UL, ULL,
// unsigned imaginary integers
IU, IUL, IULL,
// long or long double, real and imaginary
L, IL,
// long long and imaginary long long
LL, ILL,
// float and imaginary float
F, IF,
// _Float16 and imaginary _Float16
F16, IF16,
// __float80
W,
// Imaginary __float80
IW,
// _Float128
Q, F128,
// Imaginary _Float128
IQ, IF128,
// Imaginary _Bitint
IWB, IUWB,
// _Bitint
WB, UWB,
// zig fmt: on
const Tuple = struct { Suffix, []const []const u8 };
const IntSuffixes = &[_]Tuple{
.{ .U, &.{"U"} },
.{ .L, &.{"L"} },
.{ .WB, &.{"WB"} },
.{ .UL, &.{ "U", "L" } },
.{ .UWB, &.{ "U", "WB" } },
.{ .LL, &.{"LL"} },
.{ .ULL, &.{ "U", "LL" } },
.{ .I, &.{"I"} },
.{ .IWB, &.{ "I", "WB" } },
.{ .IU, &.{ "I", "U" } },
.{ .IL, &.{ "I", "L" } },
.{ .IUL, &.{ "I", "U", "L" } },
.{ .IUWB, &.{ "I", "U", "WB" } },
.{ .ILL, &.{ "I", "LL" } },
.{ .IULL, &.{ "I", "U", "LL" } },
};
const FloatSuffixes = &[_]Tuple{
.{ .F16, &.{"F16"} },
.{ .F, &.{"F"} },
.{ .L, &.{"L"} },
.{ .W, &.{"W"} },
.{ .F128, &.{"F128"} },
.{ .Q, &.{"Q"} },
.{ .I, &.{"I"} },
.{ .IL, &.{ "I", "L" } },
.{ .IF16, &.{ "I", "F16" } },
.{ .IF, &.{ "I", "F" } },
.{ .IW, &.{ "I", "W" } },
.{ .IF128, &.{ "I", "F128" } },
.{ .IQ, &.{ "I", "Q" } },
};
pub fn fromString(buf: []const u8, suffix_kind: enum { int, float }) ?Suffix {
if (buf.len == 0) return .None;
const suffixes = switch (suffix_kind) {
.float => FloatSuffixes,
.int => IntSuffixes,
};
var scratch: [4]u8 = undefined;
top: for (suffixes) |candidate| {
const tag = candidate[0];
const parts = candidate[1];
var len: usize = 0;
for (parts) |part| len += part.len;
if (len != buf.len) continue;
for (parts) |part| {
const lower = std.ascii.lowerString(&scratch, part);
if (mem.indexOf(u8, buf, part) == null and mem.indexOf(u8, buf, lower) == null) continue :top;
}
return tag;
}
return null;
}
pub fn isImaginary(suffix: Suffix) bool {
return switch (suffix) {
.I, .IL, .IF, .IU, .IUL, .ILL, .IULL, .IWB, .IUWB, .IF128, .IQ, .IW, .IF16 => true,
.None, .L, .F16, .F, .U, .UL, .LL, .ULL, .WB, .UWB, .F128, .Q, .W => false,
};
}
pub fn isSignedInteger(suffix: Suffix) bool {
return switch (suffix) {
.None, .L, .LL, .I, .IL, .ILL, .WB, .IWB => true,
.U, .UL, .ULL, .IU, .IUL, .IULL, .UWB, .IUWB => false,
.F, .IF, .F16, .F128, .IF128, .Q, .IQ, .W, .IW, .IF16 => unreachable,
};
}
pub fn signedness(suffix: Suffix) std.builtin.Signedness {
return if (suffix.isSignedInteger()) .signed else .unsigned;
}
pub fn isBitInt(suffix: Suffix) bool {
return switch (suffix) {
.WB, .UWB, .IWB, .IUWB => true,
else => false,
};
}
pub fn isFloat80(suffix: Suffix) bool {
return suffix == .W or suffix == .IW;
}
};
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Driver/Filesystem.zig | const std = @import("std");
const mem = std.mem;
const builtin = @import("builtin");
const is_windows = builtin.os.tag == .windows;
fn readFileFake(entries: []const Filesystem.Entry, path: []const u8, buf: []u8) ?[]const u8 {
@branchHint(.cold);
for (entries) |entry| {
if (mem.eql(u8, entry.path, path)) {
const len = @min(entry.contents.len, buf.len);
@memcpy(buf[0..len], entry.contents[0..len]);
return buf[0..len];
}
}
return null;
}
fn findProgramByNameFake(entries: []const Filesystem.Entry, name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
@branchHint(.cold);
if (mem.indexOfScalar(u8, name, '/') != null) {
@memcpy(buf[0..name.len], name);
return buf[0..name.len];
}
const path_env = path orelse return null;
var fib = std.heap.FixedBufferAllocator.init(buf);
var it = mem.tokenizeScalar(u8, path_env, std.fs.path.delimiter);
while (it.next()) |path_dir| {
defer fib.reset();
const full_path = std.fs.path.join(fib.allocator(), &.{ path_dir, name }) catch continue;
if (canExecuteFake(entries, full_path)) return full_path;
}
return null;
}
fn canExecuteFake(entries: []const Filesystem.Entry, path: []const u8) bool {
@branchHint(.cold);
for (entries) |entry| {
if (mem.eql(u8, entry.path, path)) {
return entry.executable;
}
}
return false;
}
fn existsFake(entries: []const Filesystem.Entry, path: []const u8) bool {
@branchHint(.cold);
var buf: [std.fs.max_path_bytes]u8 = undefined;
var fib = std.heap.FixedBufferAllocator.init(&buf);
const resolved = std.fs.path.resolvePosix(fib.allocator(), &.{path}) catch return false;
for (entries) |entry| {
if (mem.eql(u8, entry.path, resolved)) return true;
}
return false;
}
fn canExecutePosix(path: []const u8) bool {
std.posix.access(path, std.posix.X_OK) catch return false;
// Todo: ensure path is not a directory
return true;
}
/// TODO
fn canExecuteWindows(path: []const u8) bool {
_ = path;
return true;
}
/// TODO
fn findProgramByNameWindows(allocator: std.mem.Allocator, name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
_ = path;
_ = buf;
_ = name;
_ = allocator;
return null;
}
/// TODO: does WASI need special handling?
fn findProgramByNamePosix(name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
if (mem.indexOfScalar(u8, name, '/') != null) {
@memcpy(buf[0..name.len], name);
return buf[0..name.len];
}
const path_env = path orelse return null;
var fib = std.heap.FixedBufferAllocator.init(buf);
var it = mem.tokenizeScalar(u8, path_env, std.fs.path.delimiter);
while (it.next()) |path_dir| {
defer fib.reset();
const full_path = std.fs.path.join(fib.allocator(), &.{ path_dir, name }) catch continue;
if (canExecutePosix(full_path)) return full_path;
}
return null;
}
pub const Filesystem = union(enum) {
real: void,
fake: []const Entry,
const Entry = struct {
path: []const u8,
contents: []const u8 = "",
executable: bool = false,
};
const FakeDir = struct {
entries: []const Entry,
path: []const u8,
fn iterate(self: FakeDir) FakeDir.Iterator {
return .{
.entries = self.entries,
.base = self.path,
};
}
const Iterator = struct {
entries: []const Entry,
base: []const u8,
i: usize = 0,
fn next(self: *@This()) !?std.fs.Dir.Entry {
while (self.i < self.entries.len) {
const entry = self.entries[self.i];
self.i += 1;
if (entry.path.len == self.base.len) continue;
if (std.mem.startsWith(u8, entry.path, self.base)) {
const remaining = entry.path[self.base.len + 1 ..];
if (std.mem.indexOfScalar(u8, remaining, std.fs.path.sep) != null) continue;
const extension = std.fs.path.extension(remaining);
const kind: std.fs.Dir.Entry.Kind = if (extension.len == 0) .directory else .file;
return .{ .name = remaining, .kind = kind };
}
}
return null;
}
};
};
const Dir = union(enum) {
dir: std.fs.Dir,
fake: FakeDir,
pub fn iterate(self: Dir) Iterator {
return switch (self) {
.dir => |dir| .{ .iterator = dir.iterate() },
.fake => |fake| .{ .fake = fake.iterate() },
};
}
pub fn close(self: *Dir) void {
switch (self.*) {
.dir => |*d| d.close(),
.fake => {},
}
}
};
const Iterator = union(enum) {
iterator: std.fs.Dir.Iterator,
fake: FakeDir.Iterator,
pub fn next(self: *Iterator) std.fs.Dir.Iterator.Error!?std.fs.Dir.Entry {
return switch (self.*) {
.iterator => |*it| it.next(),
.fake => |*it| it.next(),
};
}
};
pub fn exists(fs: Filesystem, path: []const u8) bool {
switch (fs) {
.real => {
std.fs.cwd().access(path, .{}) catch return false;
return true;
},
.fake => |paths| return existsFake(paths, path),
}
}
pub fn joinedExists(fs: Filesystem, parts: []const []const u8) bool {
var buf: [std.fs.max_path_bytes]u8 = undefined;
var fib = std.heap.FixedBufferAllocator.init(&buf);
const joined = std.fs.path.join(fib.allocator(), parts) catch return false;
return fs.exists(joined);
}
pub fn canExecute(fs: Filesystem, path: []const u8) bool {
return switch (fs) {
.real => if (is_windows) canExecuteWindows(path) else canExecutePosix(path),
.fake => |entries| canExecuteFake(entries, path),
};
}
/// Search for an executable named `name` using platform-specific logic
/// If it's found, write the full path to `buf` and return a slice of it
/// Otherwise retun null
pub fn findProgramByName(fs: Filesystem, allocator: std.mem.Allocator, name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
std.debug.assert(name.len > 0);
return switch (fs) {
.real => if (is_windows) findProgramByNameWindows(allocator, name, path, buf) else findProgramByNamePosix(name, path, buf),
.fake => |entries| findProgramByNameFake(entries, name, path, buf),
};
}
/// Read the file at `path` into `buf`.
/// Returns null if any errors are encountered
/// Otherwise returns a slice of `buf`. If the file is larger than `buf` partial contents are returned
pub fn readFile(fs: Filesystem, path: []const u8, buf: []u8) ?[]const u8 {
return switch (fs) {
.real => {
const file = std.fs.cwd().openFile(path, .{}) catch return null;
defer file.close();
const bytes_read = file.readAll(buf) catch return null;
return buf[0..bytes_read];
},
.fake => |entries| readFileFake(entries, path, buf),
};
}
pub fn openDir(fs: Filesystem, dir_name: []const u8) std.fs.Dir.OpenError!Dir {
return switch (fs) {
.real => .{ .dir = try std.fs.cwd().openDir(dir_name, .{ .access_sub_paths = false, .iterate = true }) },
.fake => |entries| .{ .fake = .{ .entries = entries, .path = dir_name } },
};
}
};
test "Fake filesystem" {
const fs: Filesystem = .{ .fake = &.{
.{ .path = "/usr/bin" },
} };
try std.testing.expect(fs.exists("/usr/bin"));
try std.testing.expect(fs.exists("/usr/bin/foo/.."));
try std.testing.expect(!fs.exists("/usr/bin/bar"));
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Driver/GCCDetector.zig | const std = @import("std");
const Toolchain = @import("../Toolchain.zig");
const target_util = @import("../target.zig");
const system_defaults = @import("system_defaults");
const GCCVersion = @import("GCCVersion.zig");
const Multilib = @import("Multilib.zig");
const GCCDetector = @This();
is_valid: bool = false,
install_path: []const u8 = "",
parent_lib_path: []const u8 = "",
version: GCCVersion = .{},
gcc_triple: []const u8 = "",
selected: Multilib = .{},
biarch_sibling: ?Multilib = null,
pub fn deinit(self: *GCCDetector) void {
if (!self.is_valid) return;
}
pub fn appendToolPath(self: *const GCCDetector, tc: *Toolchain) !void {
if (!self.is_valid) return;
return tc.addPathFromComponents(&.{
self.parent_lib_path,
"..",
self.gcc_triple,
"bin",
}, .program);
}
fn addDefaultGCCPrefixes(prefixes: *std.ArrayListUnmanaged([]const u8), tc: *const Toolchain) !void {
const sysroot = tc.getSysroot();
const target = tc.getTarget();
if (sysroot.len == 0 and target.os.tag == .linux and tc.filesystem.exists("/opt/rh")) {
prefixes.appendAssumeCapacity("/opt/rh/gcc-toolset-12/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/gcc-toolset-11/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/gcc-toolset-10/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/devtoolset-12/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/devtoolset-11/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/devtoolset-10/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/devtoolset-9/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/devtoolset-8/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/devtoolset-7/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/devtoolset-6/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/devtoolset-4/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/devtoolset-3/root/usr");
prefixes.appendAssumeCapacity("/opt/rh/devtoolset-2/root/usr");
}
if (sysroot.len == 0) {
prefixes.appendAssumeCapacity("/usr");
} else {
var usr_path = try tc.arena.alloc(u8, 4 + sysroot.len);
@memcpy(usr_path[0..4], "/usr");
@memcpy(usr_path[4..], sysroot);
prefixes.appendAssumeCapacity(usr_path);
}
}
fn collectLibDirsAndTriples(
tc: *Toolchain,
lib_dirs: *std.ArrayListUnmanaged([]const u8),
triple_aliases: *std.ArrayListUnmanaged([]const u8),
biarch_libdirs: *std.ArrayListUnmanaged([]const u8),
biarch_triple_aliases: *std.ArrayListUnmanaged([]const u8),
) !void {
const AArch64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
const AArch64Triples: [4][]const u8 = .{ "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-redhat-linux", "aarch64-suse-linux" };
const AArch64beLibDirs: [1][]const u8 = .{"/lib"};
const AArch64beTriples: [2][]const u8 = .{ "aarch64_be-none-linux-gnu", "aarch64_be-linux-gnu" };
const ARMLibDirs: [1][]const u8 = .{"/lib"};
const ARMTriples: [1][]const u8 = .{"arm-linux-gnueabi"};
const ARMHFTriples: [4][]const u8 = .{ "arm-linux-gnueabihf", "armv7hl-redhat-linux-gnueabi", "armv6hl-suse-linux-gnueabi", "armv7hl-suse-linux-gnueabi" };
const ARMebLibDirs: [1][]const u8 = .{"/lib"};
const ARMebTriples: [1][]const u8 = .{"armeb-linux-gnueabi"};
const ARMebHFTriples: [2][]const u8 = .{ "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi" };
const AVRLibDirs: [1][]const u8 = .{"/lib"};
const AVRTriples: [1][]const u8 = .{"avr"};
const CSKYLibDirs: [1][]const u8 = .{"/lib"};
const CSKYTriples: [3][]const u8 = .{ "csky-linux-gnuabiv2", "csky-linux-uclibcabiv2", "csky-elf-noneabiv2" };
const X86_64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
const X86_64Triples: [11][]const u8 = .{
"x86_64-linux-gnu", "x86_64-unknown-linux-gnu",
"x86_64-pc-linux-gnu", "x86_64-redhat-linux6E",
"x86_64-redhat-linux", "x86_64-suse-linux",
"x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
"x86_64-slackware-linux", "x86_64-unknown-linux",
"x86_64-amazon-linux",
};
const X32Triples: [2][]const u8 = .{ "x86_64-linux-gnux32", "x86_64-pc-linux-gnux32" };
const X32LibDirs: [2][]const u8 = .{ "/libx32", "/lib" };
const X86LibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
const X86Triples: [9][]const u8 = .{
"i586-linux-gnu", "i686-linux-gnu", "i686-pc-linux-gnu",
"i386-redhat-linux6E", "i686-redhat-linux", "i386-redhat-linux",
"i586-suse-linux", "i686-montavista-linux", "i686-gnu",
};
const LoongArch64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
const LoongArch64Triples: [2][]const u8 = .{ "loongarch64-linux-gnu", "loongarch64-unknown-linux-gnu" };
const M68kLibDirs: [1][]const u8 = .{"/lib"};
const M68kTriples: [3][]const u8 = .{ "m68k-linux-gnu", "m68k-unknown-linux-gnu", "m68k-suse-linux" };
const MIPSLibDirs: [2][]const u8 = .{ "/libo32", "/lib" };
const MIPSTriples: [5][]const u8 = .{
"mips-linux-gnu", "mips-mti-linux",
"mips-mti-linux-gnu", "mips-img-linux-gnu",
"mipsisa32r6-linux-gnu",
};
const MIPSELLibDirs: [2][]const u8 = .{ "/libo32", "/lib" };
const MIPSELTriples: [3][]const u8 = .{ "mipsel-linux-gnu", "mips-img-linux-gnu", "mipsisa32r6el-linux-gnu" };
const MIPS64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
const MIPS64Triples: [6][]const u8 = .{
"mips64-linux-gnu", "mips-mti-linux-gnu",
"mips-img-linux-gnu", "mips64-linux-gnuabi64",
"mipsisa64r6-linux-gnu", "mipsisa64r6-linux-gnuabi64",
};
const MIPS64ELLibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
const MIPS64ELTriples: [6][]const u8 = .{
"mips64el-linux-gnu", "mips-mti-linux-gnu",
"mips-img-linux-gnu", "mips64el-linux-gnuabi64",
"mipsisa64r6el-linux-gnu", "mipsisa64r6el-linux-gnuabi64",
};
const MIPSN32LibDirs: [1][]const u8 = .{"/lib32"};
const MIPSN32Triples: [2][]const u8 = .{ "mips64-linux-gnuabin32", "mipsisa64r6-linux-gnuabin32" };
const MIPSN32ELLibDirs: [1][]const u8 = .{"/lib32"};
const MIPSN32ELTriples: [2][]const u8 = .{ "mips64el-linux-gnuabin32", "mipsisa64r6el-linux-gnuabin32" };
const MSP430LibDirs: [1][]const u8 = .{"/lib"};
const MSP430Triples: [1][]const u8 = .{"msp430-elf"};
const PPCLibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
const PPCTriples: [5][]const u8 = .{
"powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
// On 32-bit PowerPC systems running SUSE Linux, gcc is configured as a
// 64-bit compiler which defaults to "-m32", hence "powerpc64-suse-linux".
"powerpc64-suse-linux", "powerpc-montavista-linuxspe",
};
const PPCLELibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
const PPCLETriples: [3][]const u8 = .{ "powerpcle-linux-gnu", "powerpcle-unknown-linux-gnu", "powerpcle-linux-musl" };
const PPC64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
const PPC64Triples: [4][]const u8 = .{
"powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu",
"powerpc64-suse-linux", "ppc64-redhat-linux",
};
const PPC64LELibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
const PPC64LETriples: [5][]const u8 = .{
"powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu",
"powerpc64le-none-linux-gnu", "powerpc64le-suse-linux",
"ppc64le-redhat-linux",
};
const RISCV32LibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
const RISCV32Triples: [3][]const u8 = .{ "riscv32-unknown-linux-gnu", "riscv32-linux-gnu", "riscv32-unknown-elf" };
const RISCV64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
const RISCV64Triples: [3][]const u8 = .{
"riscv64-unknown-linux-gnu",
"riscv64-linux-gnu",
"riscv64-unknown-elf",
};
const SPARCv8LibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
const SPARCv8Triples: [2][]const u8 = .{ "sparc-linux-gnu", "sparcv8-linux-gnu" };
const SPARCv9LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
const SPARCv9Triples: [2][]const u8 = .{ "sparc64-linux-gnu", "sparcv9-linux-gnu" };
const SystemZLibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
const SystemZTriples: [5][]const u8 = .{
"s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
"s390x-suse-linux", "s390x-redhat-linux",
};
const target = tc.getTarget();
if (target.os.tag == .solaris) {
// TODO
return;
}
if (target.isAndroid()) {
const AArch64AndroidTriples: [1][]const u8 = .{"aarch64-linux-android"};
const ARMAndroidTriples: [1][]const u8 = .{"arm-linux-androideabi"};
const MIPSELAndroidTriples: [1][]const u8 = .{"mipsel-linux-android"};
const MIPS64ELAndroidTriples: [1][]const u8 = .{"mips64el-linux-android"};
const X86AndroidTriples: [1][]const u8 = .{"i686-linux-android"};
const X86_64AndroidTriples: [1][]const u8 = .{"x86_64-linux-android"};
switch (target.cpu.arch) {
.aarch64 => {
lib_dirs.appendSliceAssumeCapacity(&AArch64LibDirs);
triple_aliases.appendSliceAssumeCapacity(&AArch64AndroidTriples);
},
.arm,
.thumb,
=> {
lib_dirs.appendSliceAssumeCapacity(&ARMLibDirs);
triple_aliases.appendSliceAssumeCapacity(&ARMAndroidTriples);
},
.mipsel => {
lib_dirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
triple_aliases.appendSliceAssumeCapacity(&MIPSELAndroidTriples);
biarch_libdirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPS64ELAndroidTriples);
},
.mips64el => {
lib_dirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
triple_aliases.appendSliceAssumeCapacity(&MIPS64ELAndroidTriples);
biarch_libdirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSELAndroidTriples);
},
.x86_64 => {
lib_dirs.appendSliceAssumeCapacity(&X86_64LibDirs);
triple_aliases.appendSliceAssumeCapacity(&X86_64AndroidTriples);
biarch_libdirs.appendSliceAssumeCapacity(&X86LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&X86AndroidTriples);
},
.x86 => {
lib_dirs.appendSliceAssumeCapacity(&X86LibDirs);
triple_aliases.appendSliceAssumeCapacity(&X86AndroidTriples);
biarch_libdirs.appendSliceAssumeCapacity(&X86_64LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&X86_64AndroidTriples);
},
else => {},
}
return;
}
switch (target.cpu.arch) {
.aarch64 => {
lib_dirs.appendSliceAssumeCapacity(&AArch64LibDirs);
triple_aliases.appendSliceAssumeCapacity(&AArch64Triples);
biarch_libdirs.appendSliceAssumeCapacity(&AArch64LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&AArch64Triples);
},
.aarch64_be => {
lib_dirs.appendSliceAssumeCapacity(&AArch64beLibDirs);
triple_aliases.appendSliceAssumeCapacity(&AArch64beTriples);
biarch_libdirs.appendSliceAssumeCapacity(&AArch64beLibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&AArch64beTriples);
},
.arm, .thumb => {
lib_dirs.appendSliceAssumeCapacity(&ARMLibDirs);
if (target.abi == .gnueabihf) {
triple_aliases.appendSliceAssumeCapacity(&ARMHFTriples);
} else {
triple_aliases.appendSliceAssumeCapacity(&ARMTriples);
}
},
.armeb, .thumbeb => {
lib_dirs.appendSliceAssumeCapacity(&ARMebLibDirs);
if (target.abi == .gnueabihf) {
triple_aliases.appendSliceAssumeCapacity(&ARMebHFTriples);
} else {
triple_aliases.appendSliceAssumeCapacity(&ARMebTriples);
}
},
.avr => {
lib_dirs.appendSliceAssumeCapacity(&AVRLibDirs);
triple_aliases.appendSliceAssumeCapacity(&AVRTriples);
},
.csky => {
lib_dirs.appendSliceAssumeCapacity(&CSKYLibDirs);
triple_aliases.appendSliceAssumeCapacity(&CSKYTriples);
},
.x86_64 => {
if (target.abi == .gnux32 or target.abi == .muslx32) {
lib_dirs.appendSliceAssumeCapacity(&X32LibDirs);
triple_aliases.appendSliceAssumeCapacity(&X32Triples);
biarch_libdirs.appendSliceAssumeCapacity(&X86_64LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&X86_64Triples);
} else {
lib_dirs.appendSliceAssumeCapacity(&X86_64LibDirs);
triple_aliases.appendSliceAssumeCapacity(&X86_64Triples);
biarch_libdirs.appendSliceAssumeCapacity(&X32LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&X32Triples);
}
biarch_libdirs.appendSliceAssumeCapacity(&X86LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&X86Triples);
},
.x86 => {
lib_dirs.appendSliceAssumeCapacity(&X86LibDirs);
// MCU toolchain is 32 bit only and its triple alias is TargetTriple
// itself, which will be appended below.
if (target.os.tag != .elfiamcu) {
triple_aliases.appendSliceAssumeCapacity(&X86Triples);
biarch_libdirs.appendSliceAssumeCapacity(&X86_64LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&X86_64Triples);
biarch_libdirs.appendSliceAssumeCapacity(&X32LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&X32Triples);
}
},
.loongarch64 => {
lib_dirs.appendSliceAssumeCapacity(&LoongArch64LibDirs);
triple_aliases.appendSliceAssumeCapacity(&LoongArch64Triples);
},
.m68k => {
lib_dirs.appendSliceAssumeCapacity(&M68kLibDirs);
triple_aliases.appendSliceAssumeCapacity(&M68kTriples);
},
.mips => {
lib_dirs.appendSliceAssumeCapacity(&MIPSLibDirs);
triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
biarch_libdirs.appendSliceAssumeCapacity(&MIPS64LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPS64Triples);
biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32Triples);
},
.mipsel => {
lib_dirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
triple_aliases.appendSliceAssumeCapacity(&MIPSELTriples);
triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
biarch_libdirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPS64ELTriples);
biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32ELLibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32ELTriples);
},
.mips64 => {
lib_dirs.appendSliceAssumeCapacity(&MIPS64LibDirs);
triple_aliases.appendSliceAssumeCapacity(&MIPS64Triples);
biarch_libdirs.appendSliceAssumeCapacity(&MIPSLibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32Triples);
},
.mips64el => {
lib_dirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
triple_aliases.appendSliceAssumeCapacity(&MIPS64ELTriples);
biarch_libdirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSELTriples);
biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32ELLibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32ELTriples);
biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
},
.msp430 => {
lib_dirs.appendSliceAssumeCapacity(&MSP430LibDirs);
triple_aliases.appendSliceAssumeCapacity(&MSP430Triples);
},
.powerpc => {
lib_dirs.appendSliceAssumeCapacity(&PPCLibDirs);
triple_aliases.appendSliceAssumeCapacity(&PPCTriples);
biarch_libdirs.appendSliceAssumeCapacity(&PPC64LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&PPC64Triples);
},
.powerpcle => {
lib_dirs.appendSliceAssumeCapacity(&PPCLELibDirs);
triple_aliases.appendSliceAssumeCapacity(&PPCLETriples);
biarch_libdirs.appendSliceAssumeCapacity(&PPC64LELibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&PPC64LETriples);
},
.powerpc64 => {
lib_dirs.appendSliceAssumeCapacity(&PPC64LibDirs);
triple_aliases.appendSliceAssumeCapacity(&PPC64Triples);
biarch_libdirs.appendSliceAssumeCapacity(&PPCLibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&PPCTriples);
},
.powerpc64le => {
lib_dirs.appendSliceAssumeCapacity(&PPC64LELibDirs);
triple_aliases.appendSliceAssumeCapacity(&PPC64LETriples);
biarch_libdirs.appendSliceAssumeCapacity(&PPCLELibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&PPCLETriples);
},
.riscv32 => {
lib_dirs.appendSliceAssumeCapacity(&RISCV32LibDirs);
triple_aliases.appendSliceAssumeCapacity(&RISCV32Triples);
biarch_libdirs.appendSliceAssumeCapacity(&RISCV64LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&RISCV64Triples);
},
.riscv64 => {
lib_dirs.appendSliceAssumeCapacity(&RISCV64LibDirs);
triple_aliases.appendSliceAssumeCapacity(&RISCV64Triples);
biarch_libdirs.appendSliceAssumeCapacity(&RISCV32LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&RISCV32Triples);
},
.sparc => {
lib_dirs.appendSliceAssumeCapacity(&SPARCv8LibDirs);
triple_aliases.appendSliceAssumeCapacity(&SPARCv8Triples);
biarch_libdirs.appendSliceAssumeCapacity(&SPARCv9LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&SPARCv9Triples);
},
.sparc64 => {
lib_dirs.appendSliceAssumeCapacity(&SPARCv9LibDirs);
triple_aliases.appendSliceAssumeCapacity(&SPARCv9Triples);
biarch_libdirs.appendSliceAssumeCapacity(&SPARCv8LibDirs);
biarch_triple_aliases.appendSliceAssumeCapacity(&SPARCv8Triples);
},
.s390x => {
lib_dirs.appendSliceAssumeCapacity(&SystemZLibDirs);
triple_aliases.appendSliceAssumeCapacity(&SystemZTriples);
},
else => {},
}
}
pub fn discover(self: *GCCDetector, tc: *Toolchain) !void {
var path_buf: [std.fs.max_path_bytes]u8 = undefined;
var fib = std.heap.FixedBufferAllocator.init(&path_buf);
const target = tc.getTarget();
const biarch_variant_target = if (target.ptrBitWidth() == 32)
target_util.get64BitArchVariant(target)
else
target_util.get32BitArchVariant(target);
var candidate_lib_dirs_buffer: [16][]const u8 = undefined;
var candidate_lib_dirs = std.ArrayListUnmanaged([]const u8).initBuffer(&candidate_lib_dirs_buffer);
var candidate_triple_aliases_buffer: [16][]const u8 = undefined;
var candidate_triple_aliases = std.ArrayListUnmanaged([]const u8).initBuffer(&candidate_triple_aliases_buffer);
var candidate_biarch_lib_dirs_buffer: [16][]const u8 = undefined;
var candidate_biarch_lib_dirs = std.ArrayListUnmanaged([]const u8).initBuffer(&candidate_biarch_lib_dirs_buffer);
var candidate_biarch_triple_aliases_buffer: [16][]const u8 = undefined;
var candidate_biarch_triple_aliases = std.ArrayListUnmanaged([]const u8).initBuffer(&candidate_biarch_triple_aliases_buffer);
try collectLibDirsAndTriples(
tc,
&candidate_lib_dirs,
&candidate_triple_aliases,
&candidate_biarch_lib_dirs,
&candidate_biarch_triple_aliases,
);
var target_buf: [64]u8 = undefined;
const triple_str = target_util.toLLVMTriple(target, &target_buf);
candidate_triple_aliases.appendAssumeCapacity(triple_str);
// Also include the multiarch variant if it's different.
var biarch_buf: [64]u8 = undefined;
if (biarch_variant_target) |biarch_target| {
const biarch_triple_str = target_util.toLLVMTriple(biarch_target, &biarch_buf);
if (!std.mem.eql(u8, biarch_triple_str, triple_str)) {
candidate_triple_aliases.appendAssumeCapacity(biarch_triple_str);
}
}
var prefixes_buf: [16][]const u8 = undefined;
var prefixes = std.ArrayListUnmanaged([]const u8).initBuffer(&prefixes_buf);
const gcc_toolchain_dir = gccToolchainDir(tc);
if (gcc_toolchain_dir.len != 0) {
const adjusted = if (gcc_toolchain_dir[gcc_toolchain_dir.len - 1] == '/')
gcc_toolchain_dir[0 .. gcc_toolchain_dir.len - 1]
else
gcc_toolchain_dir;
prefixes.appendAssumeCapacity(adjusted);
} else {
const sysroot = tc.getSysroot();
if (sysroot.len > 0) {
prefixes.appendAssumeCapacity(sysroot);
try addDefaultGCCPrefixes(&prefixes, tc);
}
if (sysroot.len == 0) {
try addDefaultGCCPrefixes(&prefixes, tc);
}
// TODO: Special-case handling for Gentoo
}
const v0 = GCCVersion.parse("0.0.0");
for (prefixes.items) |prefix| {
if (!tc.filesystem.exists(prefix)) continue;
for (candidate_lib_dirs.items) |suffix| {
defer fib.reset();
const lib_dir = std.fs.path.join(fib.allocator(), &.{ prefix, suffix }) catch continue;
if (!tc.filesystem.exists(lib_dir)) continue;
const gcc_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc" });
const gcc_cross_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc-cross" });
try self.scanLibDirForGCCTriple(tc, target, lib_dir, triple_str, false, gcc_dir_exists, gcc_cross_dir_exists);
for (candidate_triple_aliases.items) |candidate| {
try self.scanLibDirForGCCTriple(tc, target, lib_dir, candidate, false, gcc_dir_exists, gcc_cross_dir_exists);
}
}
for (candidate_biarch_lib_dirs.items) |suffix| {
const lib_dir = std.fs.path.join(fib.allocator(), &.{ prefix, suffix }) catch continue;
if (!tc.filesystem.exists(lib_dir)) continue;
const gcc_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc" });
const gcc_cross_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc-cross" });
for (candidate_biarch_triple_aliases.items) |candidate| {
try self.scanLibDirForGCCTriple(tc, target, lib_dir, candidate, true, gcc_dir_exists, gcc_cross_dir_exists);
}
}
if (self.version.order(v0) == .gt) break;
}
}
fn findBiarchMultilibs(
tc: *const Toolchain,
result: *Multilib.Detected,
target: std.Target,
path: [2][]const u8,
needs_biarch_suffix: bool,
) !bool {
const suff64 = if (target.os.tag == .solaris) switch (target.cpu.arch) {
.x86, .x86_64 => "/amd64",
.sparc => "/sparcv9",
else => "/64",
} else "/64";
const alt_64 = Multilib.init(suff64, suff64, &.{ "-m32", "+m64", "-mx32" });
const alt_32 = Multilib.init("/32", "/32", &.{ "+m32", "-m64", "-mx32" });
const alt_x32 = Multilib.init("/x32", "/x32", &.{ "-m32", "-m64", "+mx32" });
const multilib_filter = Multilib.Filter{
.base = path,
.file = if (target.os.tag == .elfiamcu) "libgcc.a" else "crtbegin.o",
};
const Want = enum {
want32,
want64,
wantx32,
};
const is_x32 = target.abi == .gnux32 or target.abi == .muslx32;
const target_ptr_width = target.ptrBitWidth();
const want: Want = if (target_ptr_width == 32 and multilib_filter.exists(alt_32, tc.filesystem))
.want64
else if (target_ptr_width == 64 and is_x32 and multilib_filter.exists(alt_x32, tc.filesystem))
.want64
else if (target_ptr_width == 64 and !is_x32 and multilib_filter.exists(alt_64, tc.filesystem))
.want32
else if (target_ptr_width == 32)
if (needs_biarch_suffix) .want64 else .want32
else if (is_x32)
if (needs_biarch_suffix) .want64 else .wantx32
else if (needs_biarch_suffix) .want32 else .want64;
const default = switch (want) {
.want32 => Multilib.init("", "", &.{ "+m32", "-m64", "-mx32" }),
.want64 => Multilib.init("", "", &.{ "-m32", "+m64", "-mx32" }),
.wantx32 => Multilib.init("", "", &.{ "-m32", "-m64", "+mx32" }),
};
result.multilibs.appendSliceAssumeCapacity(&.{
default,
alt_64,
alt_32,
alt_x32,
});
result.filter(multilib_filter, tc.filesystem);
var flags: Multilib.Flags = .{};
flags.appendAssumeCapacity(if (target_ptr_width == 64 and !is_x32) "+m64" else "-m64");
flags.appendAssumeCapacity(if (target_ptr_width == 32) "+m32" else "-m32");
flags.appendAssumeCapacity(if (target_ptr_width == 64 and is_x32) "+mx32" else "-mx32");
return result.select(flags);
}
fn scanGCCForMultilibs(
self: *GCCDetector,
tc: *const Toolchain,
target: std.Target,
path: [2][]const u8,
needs_biarch_suffix: bool,
) !bool {
var detected: Multilib.Detected = .{};
if (target.cpu.arch == .csky) {
// TODO
} else if (target.cpu.arch.isMIPS()) {
// TODO
} else if (target.cpu.arch.isRISCV()) {
// TODO
} else if (target.cpu.arch == .msp430) {
// TODO
} else if (target.cpu.arch == .avr) {
// No multilibs
} else if (!try findBiarchMultilibs(tc, &detected, target, path, needs_biarch_suffix)) {
return false;
}
self.selected = detected.selected;
self.biarch_sibling = detected.biarch_sibling;
return true;
}
fn scanLibDirForGCCTriple(
self: *GCCDetector,
tc: *const Toolchain,
target: std.Target,
lib_dir: []const u8,
candidate_triple: []const u8,
needs_biarch_suffix: bool,
gcc_dir_exists: bool,
gcc_cross_dir_exists: bool,
) !void {
var path_buf: [std.fs.max_path_bytes]u8 = undefined;
var fib = std.heap.FixedBufferAllocator.init(&path_buf);
for (0..2) |i| {
if (i == 0 and !gcc_dir_exists) continue;
if (i == 1 and !gcc_cross_dir_exists) continue;
defer fib.reset();
const base: []const u8 = if (i == 0) "gcc" else "gcc-cross";
var lib_suffix_buf: [64]u8 = undefined;
var suffix_buf_fib = std.heap.FixedBufferAllocator.init(&lib_suffix_buf);
const lib_suffix = std.fs.path.join(suffix_buf_fib.allocator(), &.{ base, candidate_triple }) catch continue;
const dir_name = std.fs.path.join(fib.allocator(), &.{ lib_dir, lib_suffix }) catch continue;
var parent_dir = tc.filesystem.openDir(dir_name) catch continue;
defer parent_dir.close();
var it = parent_dir.iterate();
while (it.next() catch continue) |entry| {
if (entry.kind != .directory) continue;
const version_text = entry.name;
const candidate_version = GCCVersion.parse(version_text);
if (candidate_version.major != -1) {
// TODO: cache path so we're not repeatedly scanning
}
if (candidate_version.isLessThan(4, 1, 1, "")) continue;
switch (candidate_version.order(self.version)) {
.lt, .eq => continue,
.gt => {},
}
if (!try self.scanGCCForMultilibs(tc, target, .{ dir_name, version_text }, needs_biarch_suffix)) continue;
self.version = candidate_version;
self.gcc_triple = try tc.arena.dupe(u8, candidate_triple);
self.install_path = try std.fs.path.join(tc.arena, &.{ lib_dir, lib_suffix, version_text });
self.parent_lib_path = try std.fs.path.join(tc.arena, &.{ self.install_path, "..", "..", ".." });
self.is_valid = true;
}
}
}
fn gccToolchainDir(tc: *const Toolchain) []const u8 {
const sysroot = tc.getSysroot();
if (sysroot.len != 0) return "";
return system_defaults.gcc_install_prefix;
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Driver/GCCVersion.zig | const std = @import("std");
const mem = std.mem;
const Order = std.math.Order;
const GCCVersion = @This();
/// Raw version number text
raw: []const u8 = "",
/// -1 indicates not present
major: i32 = -1,
/// -1 indicates not present
minor: i32 = -1,
/// -1 indicates not present
patch: i32 = -1,
/// Text of parsed major version number
major_str: []const u8 = "",
/// Text of parsed major + minor version number
minor_str: []const u8 = "",
/// Patch number suffix
suffix: []const u8 = "",
/// This orders versions according to the preferred usage order, not a notion of release-time ordering
/// Higher version numbers are preferred, but nonexistent minor/patch/suffix is preferred to one that does exist
/// e.g. `4.1` is preferred over `4.0` but `4` is preferred over both `4.0` and `4.1`
pub fn isLessThan(self: GCCVersion, rhs_major: i32, rhs_minor: i32, rhs_patch: i32, rhs_suffix: []const u8) bool {
if (self.major != rhs_major) {
return self.major < rhs_major;
}
if (self.minor != rhs_minor) {
if (rhs_minor == -1) return true;
if (self.minor == -1) return false;
return self.minor < rhs_minor;
}
if (self.patch != rhs_patch) {
if (rhs_patch == -1) return true;
if (self.patch == -1) return false;
return self.patch < rhs_patch;
}
if (!mem.eql(u8, self.suffix, rhs_suffix)) {
if (rhs_suffix.len == 0) return true;
if (self.suffix.len == 0) return false;
return switch (std.mem.order(u8, self.suffix, rhs_suffix)) {
.lt => true,
.eq => unreachable,
.gt => false,
};
}
return false;
}
/// Strings in the returned GCCVersion struct have the same lifetime as `text`
pub fn parse(text: []const u8) GCCVersion {
const bad = GCCVersion{ .major = -1 };
var good = bad;
var it = mem.splitScalar(u8, text, '.');
const first = it.next().?;
const second = it.next() orelse "";
const rest = it.next() orelse "";
good.major = std.fmt.parseInt(i32, first, 10) catch return bad;
if (good.major < 0) return bad;
good.major_str = first;
if (second.len == 0) return good;
var minor_str = second;
if (rest.len == 0) {
const end = mem.indexOfNone(u8, minor_str, "0123456789") orelse minor_str.len;
if (end > 0) {
good.suffix = minor_str[end..];
minor_str = minor_str[0..end];
}
}
good.minor = std.fmt.parseInt(i32, minor_str, 10) catch return bad;
if (good.minor < 0) return bad;
good.minor_str = minor_str;
if (rest.len > 0) {
const end = mem.indexOfNone(u8, rest, "0123456789") orelse rest.len;
if (end > 0) {
const patch_num_text = rest[0..end];
good.patch = std.fmt.parseInt(i32, patch_num_text, 10) catch return bad;
if (good.patch < 0) return bad;
good.suffix = rest[end..];
}
}
return good;
}
pub fn order(a: GCCVersion, b: GCCVersion) Order {
if (a.isLessThan(b.major, b.minor, b.patch, b.suffix)) return .lt;
if (b.isLessThan(a.major, a.minor, a.patch, a.suffix)) return .gt;
return .eq;
}
/// Used for determining __GNUC__ macro values
/// This matches clang's logic for overflowing values
pub fn toUnsigned(self: GCCVersion) u32 {
var result: u32 = 0;
if (self.major > 0) result = @as(u32, @intCast(self.major)) *% 10_000;
if (self.minor > 0) result +%= @as(u32, @intCast(self.minor)) *% 100;
if (self.patch > 0) result +%= @as(u32, @intCast(self.patch));
return result;
}
test parse {
const versions = [10]GCCVersion{
parse("5"),
parse("4"),
parse("4.2"),
parse("4.0"),
parse("4.0-patched"),
parse("4.0.2"),
parse("4.0.1"),
parse("4.0.1-patched"),
parse("4.0.0"),
parse("4.0.0-patched"),
};
for (versions[0 .. versions.len - 1], versions[1..versions.len]) |first, second| {
try std.testing.expectEqual(Order.eq, first.order(first));
try std.testing.expectEqual(Order.gt, first.order(second));
try std.testing.expectEqual(Order.lt, second.order(first));
}
const last = versions[versions.len - 1];
try std.testing.expectEqual(Order.eq, last.order(last));
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Driver/Distro.zig | //! Tools for figuring out what Linux distro we're running on
const std = @import("std");
const mem = std.mem;
const Filesystem = @import("Filesystem.zig").Filesystem;
const MAX_BYTES = 1024; // TODO: Can we assume 1024 bytes enough for the info we need?
/// Value for linker `--hash-style=` argument
pub const HashStyle = enum {
both,
gnu,
};
pub const Tag = enum {
alpine,
arch,
debian_lenny,
debian_squeeze,
debian_wheezy,
debian_jessie,
debian_stretch,
debian_buster,
debian_bullseye,
debian_bookworm,
debian_trixie,
exherbo,
rhel5,
rhel6,
rhel7,
fedora,
gentoo,
open_suse,
ubuntu_hardy,
ubuntu_intrepid,
ubuntu_jaunty,
ubuntu_karmic,
ubuntu_lucid,
ubuntu_maverick,
ubuntu_natty,
ubuntu_oneiric,
ubuntu_precise,
ubuntu_quantal,
ubuntu_raring,
ubuntu_saucy,
ubuntu_trusty,
ubuntu_utopic,
ubuntu_vivid,
ubuntu_wily,
ubuntu_xenial,
ubuntu_yakkety,
ubuntu_zesty,
ubuntu_artful,
ubuntu_bionic,
ubuntu_cosmic,
ubuntu_disco,
ubuntu_eoan,
ubuntu_focal,
ubuntu_groovy,
ubuntu_hirsute,
ubuntu_impish,
ubuntu_jammy,
ubuntu_kinetic,
ubuntu_lunar,
unknown,
pub fn getHashStyle(self: Tag) HashStyle {
if (self.isOpenSUSE()) return .both;
return switch (self) {
.ubuntu_lucid,
.ubuntu_jaunty,
.ubuntu_karmic,
=> .both,
else => .gnu,
};
}
pub fn isRedhat(self: Tag) bool {
return switch (self) {
.fedora,
.rhel5,
.rhel6,
.rhel7,
=> true,
else => false,
};
}
pub fn isOpenSUSE(self: Tag) bool {
return self == .open_suse;
}
pub fn isDebian(self: Tag) bool {
return switch (self) {
.debian_lenny,
.debian_squeeze,
.debian_wheezy,
.debian_jessie,
.debian_stretch,
.debian_buster,
.debian_bullseye,
.debian_bookworm,
.debian_trixie,
=> true,
else => false,
};
}
pub fn isUbuntu(self: Tag) bool {
return switch (self) {
.ubuntu_hardy,
.ubuntu_intrepid,
.ubuntu_jaunty,
.ubuntu_karmic,
.ubuntu_lucid,
.ubuntu_maverick,
.ubuntu_natty,
.ubuntu_oneiric,
.ubuntu_precise,
.ubuntu_quantal,
.ubuntu_raring,
.ubuntu_saucy,
.ubuntu_trusty,
.ubuntu_utopic,
.ubuntu_vivid,
.ubuntu_wily,
.ubuntu_xenial,
.ubuntu_yakkety,
.ubuntu_zesty,
.ubuntu_artful,
.ubuntu_bionic,
.ubuntu_cosmic,
.ubuntu_disco,
.ubuntu_eoan,
.ubuntu_focal,
.ubuntu_groovy,
.ubuntu_hirsute,
.ubuntu_impish,
.ubuntu_jammy,
.ubuntu_kinetic,
.ubuntu_lunar,
=> true,
else => false,
};
}
pub fn isAlpine(self: Tag) bool {
return self == .alpine;
}
pub fn isGentoo(self: Tag) bool {
return self == .gentoo;
}
};
fn scanForOsRelease(buf: []const u8) ?Tag {
var it = mem.splitScalar(u8, buf, '\n');
while (it.next()) |line| {
if (mem.startsWith(u8, line, "ID=")) {
const rest = line["ID=".len..];
if (mem.eql(u8, rest, "alpine")) return .alpine;
if (mem.eql(u8, rest, "fedora")) return .fedora;
if (mem.eql(u8, rest, "gentoo")) return .gentoo;
if (mem.eql(u8, rest, "arch")) return .arch;
if (mem.eql(u8, rest, "sles")) return .open_suse;
if (mem.eql(u8, rest, "opensuse")) return .open_suse;
if (mem.eql(u8, rest, "exherbo")) return .exherbo;
}
}
return null;
}
fn detectOsRelease(fs: Filesystem) ?Tag {
var buf: [MAX_BYTES]u8 = undefined;
const data = fs.readFile("/etc/os-release", &buf) orelse fs.readFile("/usr/lib/os-release", &buf) orelse return null;
return scanForOsRelease(data);
}
fn scanForLSBRelease(buf: []const u8) ?Tag {
var it = mem.splitScalar(u8, buf, '\n');
while (it.next()) |line| {
if (mem.startsWith(u8, line, "DISTRIB_CODENAME=")) {
const rest = line["DISTRIB_CODENAME=".len..];
if (mem.eql(u8, rest, "hardy")) return .ubuntu_hardy;
if (mem.eql(u8, rest, "intrepid")) return .ubuntu_intrepid;
if (mem.eql(u8, rest, "jaunty")) return .ubuntu_jaunty;
if (mem.eql(u8, rest, "karmic")) return .ubuntu_karmic;
if (mem.eql(u8, rest, "lucid")) return .ubuntu_lucid;
if (mem.eql(u8, rest, "maverick")) return .ubuntu_maverick;
if (mem.eql(u8, rest, "natty")) return .ubuntu_natty;
if (mem.eql(u8, rest, "oneiric")) return .ubuntu_oneiric;
if (mem.eql(u8, rest, "precise")) return .ubuntu_precise;
if (mem.eql(u8, rest, "quantal")) return .ubuntu_quantal;
if (mem.eql(u8, rest, "raring")) return .ubuntu_raring;
if (mem.eql(u8, rest, "saucy")) return .ubuntu_saucy;
if (mem.eql(u8, rest, "trusty")) return .ubuntu_trusty;
if (mem.eql(u8, rest, "utopic")) return .ubuntu_utopic;
if (mem.eql(u8, rest, "vivid")) return .ubuntu_vivid;
if (mem.eql(u8, rest, "wily")) return .ubuntu_wily;
if (mem.eql(u8, rest, "xenial")) return .ubuntu_xenial;
if (mem.eql(u8, rest, "yakkety")) return .ubuntu_yakkety;
if (mem.eql(u8, rest, "zesty")) return .ubuntu_zesty;
if (mem.eql(u8, rest, "artful")) return .ubuntu_artful;
if (mem.eql(u8, rest, "bionic")) return .ubuntu_bionic;
if (mem.eql(u8, rest, "cosmic")) return .ubuntu_cosmic;
if (mem.eql(u8, rest, "disco")) return .ubuntu_disco;
if (mem.eql(u8, rest, "eoan")) return .ubuntu_eoan;
if (mem.eql(u8, rest, "focal")) return .ubuntu_focal;
if (mem.eql(u8, rest, "groovy")) return .ubuntu_groovy;
if (mem.eql(u8, rest, "hirsute")) return .ubuntu_hirsute;
if (mem.eql(u8, rest, "impish")) return .ubuntu_impish;
if (mem.eql(u8, rest, "jammy")) return .ubuntu_jammy;
if (mem.eql(u8, rest, "kinetic")) return .ubuntu_kinetic;
if (mem.eql(u8, rest, "lunar")) return .ubuntu_lunar;
}
}
return null;
}
fn detectLSBRelease(fs: Filesystem) ?Tag {
var buf: [MAX_BYTES]u8 = undefined;
const data = fs.readFile("/etc/lsb-release", &buf) orelse return null;
return scanForLSBRelease(data);
}
fn scanForRedHat(buf: []const u8) Tag {
if (mem.startsWith(u8, buf, "Fedora release")) return .fedora;
if (mem.startsWith(u8, buf, "Red Hat Enterprise Linux") or mem.startsWith(u8, buf, "CentOS") or mem.startsWith(u8, buf, "Scientific Linux")) {
if (mem.indexOfPos(u8, buf, 0, "release 7") != null) return .rhel7;
if (mem.indexOfPos(u8, buf, 0, "release 6") != null) return .rhel6;
if (mem.indexOfPos(u8, buf, 0, "release 5") != null) return .rhel5;
}
return .unknown;
}
fn detectRedhat(fs: Filesystem) ?Tag {
var buf: [MAX_BYTES]u8 = undefined;
const data = fs.readFile("/etc/redhat-release", &buf) orelse return null;
return scanForRedHat(data);
}
fn scanForDebian(buf: []const u8) Tag {
var it = mem.splitScalar(u8, buf, '.');
if (std.fmt.parseInt(u8, it.next().?, 10)) |major| {
return switch (major) {
5 => .debian_lenny,
6 => .debian_squeeze,
7 => .debian_wheezy,
8 => .debian_jessie,
9 => .debian_stretch,
10 => .debian_buster,
11 => .debian_bullseye,
12 => .debian_bookworm,
13 => .debian_trixie,
else => .unknown,
};
} else |_| {}
it = mem.splitScalar(u8, buf, '\n');
const name = it.next().?;
if (mem.eql(u8, name, "squeeze/sid")) return .debian_squeeze;
if (mem.eql(u8, name, "wheezy/sid")) return .debian_wheezy;
if (mem.eql(u8, name, "jessie/sid")) return .debian_jessie;
if (mem.eql(u8, name, "stretch/sid")) return .debian_stretch;
if (mem.eql(u8, name, "buster/sid")) return .debian_buster;
if (mem.eql(u8, name, "bullseye/sid")) return .debian_bullseye;
if (mem.eql(u8, name, "bookworm/sid")) return .debian_bookworm;
return .unknown;
}
fn detectDebian(fs: Filesystem) ?Tag {
var buf: [MAX_BYTES]u8 = undefined;
const data = fs.readFile("/etc/debian_version", &buf) orelse return null;
return scanForDebian(data);
}
pub fn detect(target: std.Target, fs: Filesystem) Tag {
if (target.os.tag != .linux) return .unknown;
if (detectOsRelease(fs)) |tag| return tag;
if (detectLSBRelease(fs)) |tag| return tag;
if (detectRedhat(fs)) |tag| return tag;
if (detectDebian(fs)) |tag| return tag;
if (fs.exists("/etc/gentoo-release")) return .gentoo;
return .unknown;
}
test scanForDebian {
try std.testing.expectEqual(Tag.debian_squeeze, scanForDebian("squeeze/sid"));
try std.testing.expectEqual(Tag.debian_bullseye, scanForDebian("11.1.2"));
try std.testing.expectEqual(Tag.unknown, scanForDebian("None"));
try std.testing.expectEqual(Tag.unknown, scanForDebian(""));
}
test scanForRedHat {
try std.testing.expectEqual(Tag.fedora, scanForRedHat("Fedora release 7"));
try std.testing.expectEqual(Tag.rhel7, scanForRedHat("Red Hat Enterprise Linux release 7"));
try std.testing.expectEqual(Tag.rhel5, scanForRedHat("CentOS release 5"));
try std.testing.expectEqual(Tag.unknown, scanForRedHat("CentOS release 4"));
try std.testing.expectEqual(Tag.unknown, scanForRedHat(""));
}
test scanForLSBRelease {
const text =
\\DISTRIB_ID=Ubuntu
\\DISTRIB_RELEASE=20.04
\\DISTRIB_CODENAME=focal
\\DISTRIB_DESCRIPTION="Ubuntu 20.04.6 LTS"
\\
;
try std.testing.expectEqual(Tag.ubuntu_focal, scanForLSBRelease(text).?);
}
test scanForOsRelease {
const text =
\\NAME="Alpine Linux"
\\ID=alpine
\\VERSION_ID=3.18.2
\\PRETTY_NAME="Alpine Linux v3.18"
\\HOME_URL="https://alpinelinux.org/"
\\BUG_REPORT_URL="https://gitlab.alpinelinux.org/alpine/aports/-/issues"
\\
;
try std.testing.expectEqual(Tag.alpine, scanForOsRelease(text).?);
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Driver/Multilib.zig | const std = @import("std");
const Filesystem = @import("Filesystem.zig").Filesystem;
pub const Flags = std.BoundedArray([]const u8, 6);
/// Large enough for GCCDetector for Linux; may need to be increased to support other toolchains.
const max_multilibs = 4;
const MultilibArray = std.BoundedArray(Multilib, max_multilibs);
pub const Detected = struct {
multilibs: MultilibArray = .{},
selected: Multilib = .{},
biarch_sibling: ?Multilib = null,
pub fn filter(self: *Detected, multilib_filter: Filter, fs: Filesystem) void {
var found_count: usize = 0;
for (self.multilibs.constSlice()) |multilib| {
if (multilib_filter.exists(multilib, fs)) {
self.multilibs.set(found_count, multilib);
found_count += 1;
}
}
self.multilibs.resize(found_count) catch unreachable;
}
pub fn select(self: *Detected, flags: Flags) !bool {
var filtered: MultilibArray = .{};
for (self.multilibs.constSlice()) |multilib| {
for (multilib.flags.constSlice()) |multilib_flag| {
const matched = for (flags.constSlice()) |arg_flag| {
if (std.mem.eql(u8, arg_flag[1..], multilib_flag[1..])) break arg_flag;
} else multilib_flag;
if (matched[0] != multilib_flag[0]) break;
} else {
filtered.appendAssumeCapacity(multilib);
}
}
if (filtered.len == 0) return false;
if (filtered.len == 1) {
self.selected = filtered.get(0);
return true;
}
return error.TooManyMultilibs;
}
};
pub const Filter = struct {
base: [2][]const u8,
file: []const u8,
pub fn exists(self: Filter, m: Multilib, fs: Filesystem) bool {
return fs.joinedExists(&.{ self.base[0], self.base[1], m.gcc_suffix, self.file });
}
};
const Multilib = @This();
gcc_suffix: []const u8 = "",
os_suffix: []const u8 = "",
include_suffix: []const u8 = "",
flags: Flags = .{},
priority: u32 = 0,
pub fn init(gcc_suffix: []const u8, os_suffix: []const u8, flags: []const []const u8) Multilib {
var self: Multilib = .{
.gcc_suffix = gcc_suffix,
.os_suffix = os_suffix,
};
self.flags.appendSliceAssumeCapacity(flags);
return self;
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Builtins/TypeDescription.zig | const std = @import("std");
const TypeDescription = @This();
prefix: []const Prefix,
spec: Spec,
suffix: []const Suffix,
pub const Component = union(enum) {
prefix: Prefix,
spec: Spec,
suffix: Suffix,
};
pub const ComponentIterator = struct {
str: []const u8,
idx: usize,
pub fn init(str: []const u8) ComponentIterator {
return .{
.str = str,
.idx = 0,
};
}
pub fn peek(self: *ComponentIterator) ?Component {
const idx = self.idx;
defer self.idx = idx;
return self.next();
}
pub fn next(self: *ComponentIterator) ?Component {
if (self.idx == self.str.len) return null;
const c = self.str[self.idx];
self.idx += 1;
switch (c) {
'L' => {
if (self.str[self.idx] != 'L') return .{ .prefix = .L };
self.idx += 1;
if (self.str[self.idx] != 'L') return .{ .prefix = .LL };
self.idx += 1;
return .{ .prefix = .LLL };
},
'Z' => return .{ .prefix = .Z },
'W' => return .{ .prefix = .W },
'N' => return .{ .prefix = .N },
'O' => return .{ .prefix = .O },
'S' => {
if (self.str[self.idx] == 'J') {
self.idx += 1;
return .{ .spec = .SJ };
}
return .{ .prefix = .S };
},
'U' => return .{ .prefix = .U },
'I' => return .{ .prefix = .I },
'v' => return .{ .spec = .v },
'b' => return .{ .spec = .b },
'c' => return .{ .spec = .c },
's' => return .{ .spec = .s },
'i' => return .{ .spec = .i },
'h' => return .{ .spec = .h },
'x' => return .{ .spec = .x },
'y' => return .{ .spec = .y },
'f' => return .{ .spec = .f },
'd' => return .{ .spec = .d },
'z' => return .{ .spec = .z },
'w' => return .{ .spec = .w },
'F' => return .{ .spec = .F },
'G' => return .{ .spec = .G },
'H' => return .{ .spec = .H },
'M' => return .{ .spec = .M },
'a' => return .{ .spec = .a },
'A' => return .{ .spec = .A },
'V', 'q', 'E' => {
const start = self.idx;
while (std.ascii.isDigit(self.str[self.idx])) : (self.idx += 1) {}
const count = std.fmt.parseUnsigned(u32, self.str[start..self.idx], 10) catch unreachable;
return switch (c) {
'V' => .{ .spec = .{ .V = count } },
'q' => .{ .spec = .{ .q = count } },
'E' => .{ .spec = .{ .E = count } },
else => unreachable,
};
},
'X' => {
defer self.idx += 1;
switch (self.str[self.idx]) {
'f' => return .{ .spec = .{ .X = .float } },
'd' => return .{ .spec = .{ .X = .double } },
'L' => {
self.idx += 1;
return .{ .spec = .{ .X = .longdouble } };
},
else => unreachable,
}
},
'Y' => return .{ .spec = .Y },
'P' => return .{ .spec = .P },
'J' => return .{ .spec = .J },
'K' => return .{ .spec = .K },
'p' => return .{ .spec = .p },
'.' => {
// can only appear at end of param string; indicates varargs function
std.debug.assert(self.idx == self.str.len);
return null;
},
'!' => {
std.debug.assert(self.str.len == 1);
return .{ .spec = .@"!" };
},
'*' => {
if (self.idx < self.str.len and std.ascii.isDigit(self.str[self.idx])) {
defer self.idx += 1;
const addr_space = self.str[self.idx] - '0';
return .{ .suffix = .{ .@"*" = addr_space } };
} else {
return .{ .suffix = .{ .@"*" = null } };
}
},
'C' => return .{ .suffix = .C },
'D' => return .{ .suffix = .D },
'R' => return .{ .suffix = .R },
else => unreachable,
}
return null;
}
};
pub const TypeIterator = struct {
param_str: []const u8,
prefix: [4]Prefix,
spec: Spec,
suffix: [4]Suffix,
idx: usize,
pub fn init(param_str: []const u8) TypeIterator {
return .{
.param_str = param_str,
.prefix = undefined,
.spec = undefined,
.suffix = undefined,
.idx = 0,
};
}
/// Returned `TypeDescription` contains fields which are slices into the underlying `TypeIterator`
/// The returned value is invalidated when `.next()` is called again or the TypeIterator goes out
// of scope.
pub fn next(self: *TypeIterator) ?TypeDescription {
var it = ComponentIterator.init(self.param_str[self.idx..]);
defer self.idx += it.idx;
var prefix_count: usize = 0;
var maybe_spec: ?Spec = null;
var suffix_count: usize = 0;
while (it.peek()) |component| {
switch (component) {
.prefix => |prefix| {
if (maybe_spec != null) break;
self.prefix[prefix_count] = prefix;
prefix_count += 1;
},
.spec => |spec| {
if (maybe_spec != null) break;
maybe_spec = spec;
},
.suffix => |suffix| {
std.debug.assert(maybe_spec != null);
self.suffix[suffix_count] = suffix;
suffix_count += 1;
},
}
_ = it.next();
}
if (maybe_spec) |spec| {
return TypeDescription{
.prefix = self.prefix[0..prefix_count],
.spec = spec,
.suffix = self.suffix[0..suffix_count],
};
}
return null;
}
};
const Prefix = enum {
/// long (e.g. Li for 'long int', Ld for 'long double')
L,
/// long long (e.g. LLi for 'long long int', LLd for __float128)
LL,
/// __int128_t (e.g. LLLi)
LLL,
/// int32_t (require a native 32-bit integer type on the target)
Z,
/// int64_t (require a native 64-bit integer type on the target)
W,
/// 'int' size if target is LP64, 'L' otherwise.
N,
/// long for OpenCL targets, long long otherwise.
O,
/// signed
S,
/// unsigned
U,
/// Required to constant fold to an integer constant expression.
I,
};
const Spec = union(enum) {
/// void
v,
/// boolean
b,
/// char
c,
/// short
s,
/// int
i,
/// half (__fp16, OpenCL)
h,
/// half (_Float16)
x,
/// half (__bf16)
y,
/// float
f,
/// double
d,
/// size_t
z,
/// wchar_t
w,
/// constant CFString
F,
/// id
G,
/// SEL
H,
/// struct objc_super
M,
/// __builtin_va_list
a,
/// "reference" to __builtin_va_list
A,
/// Vector, followed by the number of elements and the base type.
V: u32,
/// Scalable vector, followed by the number of elements and the base type.
q: u32,
/// ext_vector, followed by the number of elements and the base type.
E: u32,
/// _Complex, followed by the base type.
X: enum {
float,
double,
longdouble,
},
/// ptrdiff_t
Y,
/// FILE
P,
/// jmp_buf
J,
/// sigjmp_buf
SJ,
/// ucontext_t
K,
/// pid_t
p,
/// Used to indicate a builtin with target-dependent param types. Must appear by itself
@"!",
};
const Suffix = union(enum) {
/// pointer (optionally followed by an address space number,if no address space is specified than any address space will be accepted)
@"*": ?u8,
/// const
C,
/// volatile
D,
/// restrict
R,
};
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Builtins/Builtin.def | const TargetSet = Properties.TargetSet;
# TODO this file is generated from LLVM sources and
# needs cleanup to be considered source.
pub const max_param_count = 12;
_Block_object_assign
.param_str = "vv*vC*iC"
.header = .blocks
.attributes = .{ .lib_function_without_prefix = true }
_Block_object_dispose
.param_str = "vvC*iC"
.header = .blocks
.attributes = .{ .lib_function_without_prefix = true }
_Exit
.param_str = "vi"
.header = .stdlib
.attributes = .{ .noreturn = true, .lib_function_without_prefix = true }
_InterlockedAnd
.param_str = "NiNiD*Ni"
.language = .all_ms_languages
_InterlockedAnd16
.param_str = "ssD*s"
.language = .all_ms_languages
_InterlockedAnd8
.param_str = "ccD*c"
.language = .all_ms_languages
_InterlockedCompareExchange
.param_str = "NiNiD*NiNi"
.language = .all_ms_languages
_InterlockedCompareExchange16
.param_str = "ssD*ss"
.language = .all_ms_languages
_InterlockedCompareExchange64
.param_str = "LLiLLiD*LLiLLi"
.language = .all_ms_languages
_InterlockedCompareExchange8
.param_str = "ccD*cc"
.language = .all_ms_languages
_InterlockedCompareExchangePointer
.param_str = "v*v*D*v*v*"
.language = .all_ms_languages
_InterlockedCompareExchangePointer_nf
.param_str = "v*v*D*v*v*"
.language = .all_ms_languages
_InterlockedDecrement
.param_str = "NiNiD*"
.language = .all_ms_languages
_InterlockedDecrement16
.param_str = "ssD*"
.language = .all_ms_languages
_InterlockedExchange
.param_str = "NiNiD*Ni"
.language = .all_ms_languages
_InterlockedExchange16
.param_str = "ssD*s"
.language = .all_ms_languages
_InterlockedExchange8
.param_str = "ccD*c"
.language = .all_ms_languages
_InterlockedExchangeAdd
.param_str = "NiNiD*Ni"
.language = .all_ms_languages
_InterlockedExchangeAdd16
.param_str = "ssD*s"
.language = .all_ms_languages
_InterlockedExchangeAdd8
.param_str = "ccD*c"
.language = .all_ms_languages
_InterlockedExchangePointer
.param_str = "v*v*D*v*"
.language = .all_ms_languages
_InterlockedExchangeSub
.param_str = "NiNiD*Ni"
.language = .all_ms_languages
_InterlockedExchangeSub16
.param_str = "ssD*s"
.language = .all_ms_languages
_InterlockedExchangeSub8
.param_str = "ccD*c"
.language = .all_ms_languages
_InterlockedIncrement
.param_str = "NiNiD*"
.language = .all_ms_languages
_InterlockedIncrement16
.param_str = "ssD*"
.language = .all_ms_languages
_InterlockedOr
.param_str = "NiNiD*Ni"
.language = .all_ms_languages
_InterlockedOr16
.param_str = "ssD*s"
.language = .all_ms_languages
_InterlockedOr8
.param_str = "ccD*c"
.language = .all_ms_languages
_InterlockedXor
.param_str = "NiNiD*Ni"
.language = .all_ms_languages
_InterlockedXor16
.param_str = "ssD*s"
.language = .all_ms_languages
_InterlockedXor8
.param_str = "ccD*c"
.language = .all_ms_languages
_MoveFromCoprocessor
.param_str = "UiIUiIUiIUiIUiIUi"
.language = .all_ms_languages
.target_set = TargetSet.initOne(.arm)
_MoveFromCoprocessor2
.param_str = "UiIUiIUiIUiIUiIUi"
.language = .all_ms_languages
.target_set = TargetSet.initOne(.arm)
_MoveToCoprocessor
.param_str = "vUiIUiIUiIUiIUiIUi"
.language = .all_ms_languages
.target_set = TargetSet.initOne(.arm)
_MoveToCoprocessor2
.param_str = "vUiIUiIUiIUiIUiIUi"
.language = .all_ms_languages
.target_set = TargetSet.initOne(.arm)
_ReturnAddress
.param_str = "v*"
.language = .all_ms_languages
__GetExceptionInfo
.param_str = "v*."
.language = .all_ms_languages
.attributes = .{ .custom_typecheck = true, .eval_args = false }
__abnormal_termination
.param_str = "i"
.language = .all_ms_languages
__annotation
.param_str = "wC*."
.language = .all_ms_languages
__arithmetic_fence
.param_str = "v."
.attributes = .{ .custom_typecheck = true, .const_evaluable = true }
__assume
.param_str = "vb"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
__atomic_always_lock_free
.param_str = "bzvCD*"
.attributes = .{ .const_evaluable = true }
__atomic_clear
.param_str = "vvD*i"
__atomic_is_lock_free
.param_str = "bzvCD*"
.attributes = .{ .const_evaluable = true }
__atomic_signal_fence
.param_str = "vi"
__atomic_test_and_set
.param_str = "bvD*i"
__atomic_thread_fence
.param_str = "vi"
__builtin___CFStringMakeConstantString
.param_str = "FC*cC*"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin___NSStringMakeConstantString
.param_str = "FC*cC*"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin___clear_cache
.param_str = "vc*c*"
__builtin___fprintf_chk
.param_str = "iP*RicC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .printf, .format_string_position = 2 }
__builtin___get_unsafe_stack_bottom
.param_str = "v*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___get_unsafe_stack_ptr
.param_str = "v*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___get_unsafe_stack_start
.param_str = "v*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___get_unsafe_stack_top
.param_str = "v*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___memccpy_chk
.param_str = "v*v*vC*izz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___memcpy_chk
.param_str = "v*v*vC*zz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___memmove_chk
.param_str = "v*v*vC*zz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___mempcpy_chk
.param_str = "v*v*vC*zz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___memset_chk
.param_str = "v*v*izz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___printf_chk
.param_str = "iicC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .printf, .format_string_position = 1 }
__builtin___snprintf_chk
.param_str = "ic*RzizcC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .printf, .format_string_position = 4 }
__builtin___sprintf_chk
.param_str = "ic*RizcC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .printf, .format_string_position = 3 }
__builtin___stpcpy_chk
.param_str = "c*c*cC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___stpncpy_chk
.param_str = "c*c*cC*zz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___strcat_chk
.param_str = "c*c*cC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___strcpy_chk
.param_str = "c*c*cC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___strlcat_chk
.param_str = "zc*cC*zz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___strlcpy_chk
.param_str = "zc*cC*zz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___strncat_chk
.param_str = "c*c*cC*zz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___strncpy_chk
.param_str = "c*c*cC*zz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin___vfprintf_chk
.param_str = "iP*RicC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vprintf, .format_string_position = 2 }
__builtin___vprintf_chk
.param_str = "iicC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vprintf, .format_string_position = 1 }
__builtin___vsnprintf_chk
.param_str = "ic*RzizcC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vprintf, .format_string_position = 4 }
__builtin___vsprintf_chk
.param_str = "ic*RizcC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vprintf, .format_string_position = 3 }
__builtin_abort
.param_str = "v"
.attributes = .{ .noreturn = true, .lib_function_with_builtin_prefix = true }
__builtin_abs
.param_str = "ii"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_acos
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_acosf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_acosf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_acosh
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_acoshf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_acoshf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_acoshl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_acosl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_add_overflow
.param_str = "b."
.attributes = .{ .custom_typecheck = true, .const_evaluable = true }
__builtin_addc
.param_str = "UiUiCUiCUiCUi*"
__builtin_addcb
.param_str = "UcUcCUcCUcCUc*"
__builtin_addcl
.param_str = "ULiULiCULiCULiCULi*"
__builtin_addcll
.param_str = "ULLiULLiCULLiCULLiCULLi*"
__builtin_addcs
.param_str = "UsUsCUsCUsCUs*"
__builtin_align_down
.param_str = "v*vC*z"
.attributes = .{ .@"const" = true, .custom_typecheck = true, .const_evaluable = true }
__builtin_align_up
.param_str = "v*vC*z"
.attributes = .{ .@"const" = true, .custom_typecheck = true, .const_evaluable = true }
__builtin_alloca
.param_str = "v*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_alloca_uninitialized
.param_str = "v*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_alloca_with_align
.param_str = "v*zIz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_alloca_with_align_uninitialized
.param_str = "v*zIz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_amdgcn_alignbit
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_alignbyte
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_atomic_dec32
.param_str = "UZiUZiD*UZiUicC*"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_atomic_dec64
.param_str = "UWiUWiD*UWiUicC*"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_atomic_inc32
.param_str = "UZiUZiD*UZiUicC*"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_atomic_inc64
.param_str = "UWiUWiD*UWiUicC*"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_buffer_wbinvl1
.param_str = "v"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_class
.param_str = "bdi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_classf
.param_str = "bfi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cosf
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cubeid
.param_str = "ffff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cubema
.param_str = "ffff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cubesc
.param_str = "ffff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cubetc
.param_str = "ffff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cvt_pk_i16
.param_str = "E2sii"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cvt_pk_u16
.param_str = "E2UsUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cvt_pk_u8_f32
.param_str = "UifUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cvt_pknorm_i16
.param_str = "E2sff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cvt_pknorm_u16
.param_str = "E2Usff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_cvt_pkrtz
.param_str = "E2hff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_dispatch_ptr
.param_str = "v*4"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_div_fixup
.param_str = "dddd"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_div_fixupf
.param_str = "ffff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_div_fmas
.param_str = "ddddb"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_div_fmasf
.param_str = "ffffb"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_div_scale
.param_str = "dddbb*"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_div_scalef
.param_str = "fffbb*"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_ds_append
.param_str = "ii*3"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_ds_bpermute
.param_str = "iii"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_ds_consume
.param_str = "ii*3"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_ds_faddf
.param_str = "ff*3fIiIiIb"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_ds_fmaxf
.param_str = "ff*3fIiIiIb"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_ds_fminf
.param_str = "ff*3fIiIiIb"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_ds_permute
.param_str = "iii"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_ds_swizzle
.param_str = "iiIi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_endpgm
.param_str = "v"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .noreturn = true }
__builtin_amdgcn_exp2f
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_fcmp
.param_str = "WUiddIi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_fcmpf
.param_str = "WUiffIi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_fence
.param_str = "vUicC*"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_fmed3f
.param_str = "ffff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_fract
.param_str = "dd"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_fractf
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_frexp_exp
.param_str = "id"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_frexp_expf
.param_str = "if"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_frexp_mant
.param_str = "dd"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_frexp_mantf
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_grid_size_x
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_grid_size_y
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_grid_size_z
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_groupstaticsize
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_iglp_opt
.param_str = "vIi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_implicitarg_ptr
.param_str = "v*4"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_interp_mov
.param_str = "fUiUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_interp_p1
.param_str = "ffUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_interp_p1_f16
.param_str = "ffUiUibUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_interp_p2
.param_str = "fffUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_interp_p2_f16
.param_str = "hffUiUibUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_is_private
.param_str = "bvC*0"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_is_shared
.param_str = "bvC*0"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_kernarg_segment_ptr
.param_str = "v*4"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_ldexp
.param_str = "ddi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_ldexpf
.param_str = "ffi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_lerp
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_log_clampf
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_logf
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_mbcnt_hi
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_mbcnt_lo
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_mqsad_pk_u16_u8
.param_str = "WUiWUiUiWUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_mqsad_u32_u8
.param_str = "V4UiWUiUiV4Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_msad_u8
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_qsad_pk_u16_u8
.param_str = "WUiWUiUiWUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_queue_ptr
.param_str = "v*4"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_rcp
.param_str = "dd"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_rcpf
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_read_exec
.param_str = "WUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_read_exec_hi
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_read_exec_lo
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_readfirstlane
.param_str = "ii"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_readlane
.param_str = "iii"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_rsq
.param_str = "dd"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_rsq_clamp
.param_str = "dd"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_rsq_clampf
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_rsqf
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_s_barrier
.param_str = "v"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_dcache_inv
.param_str = "v"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_decperflevel
.param_str = "vIi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_getpc
.param_str = "WUi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_getreg
.param_str = "UiIi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_incperflevel
.param_str = "vIi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_sendmsg
.param_str = "vIiUi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_sendmsghalt
.param_str = "vIiUi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_setprio
.param_str = "vIs"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_setreg
.param_str = "vIiUi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_sleep
.param_str = "vIi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_s_waitcnt
.param_str = "vIi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_sad_hi_u8
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_sad_u16
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_sad_u8
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_sbfe
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_sched_barrier
.param_str = "vIi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_sched_group_barrier
.param_str = "vIiIiIi"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_sicmp
.param_str = "WUiiiIi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_sicmpl
.param_str = "WUiWiWiIi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_sinf
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_sqrt
.param_str = "dd"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_sqrtf
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_trig_preop
.param_str = "ddi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_trig_preopf
.param_str = "ffi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_ubfe
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_uicmp
.param_str = "WUiUiUiIi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_uicmpl
.param_str = "WUiWUiWUiIi"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_wave_barrier
.param_str = "v"
.target_set = TargetSet.initOne(.amdgpu)
__builtin_amdgcn_workgroup_id_x
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_workgroup_id_y
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_workgroup_id_z
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_workgroup_size_x
.param_str = "Us"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_workgroup_size_y
.param_str = "Us"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_workgroup_size_z
.param_str = "Us"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_workitem_id_x
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_workitem_id_y
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_amdgcn_workitem_id_z
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_annotation
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__builtin_arm_cdp
.param_str = "vUIiUIiUIiUIiUIiUIi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_cdp2
.param_str = "vUIiUIiUIiUIiUIiUIi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_clrex
.param_str = "v"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__builtin_arm_cls
.param_str = "UiZUi"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_cls64
.param_str = "UiWUi"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_clz
.param_str = "UiZUi"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_clz64
.param_str = "UiWUi"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_cmse_TT
.param_str = "Uiv*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_cmse_TTA
.param_str = "Uiv*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_cmse_TTAT
.param_str = "Uiv*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_cmse_TTT
.param_str = "Uiv*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_dbg
.param_str = "vUi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_dmb
.param_str = "vUi"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_dsb
.param_str = "vUi"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_get_fpscr
.param_str = "Ui"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_isb
.param_str = "vUi"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_ldaex
.param_str = "v."
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .custom_typecheck = true }
__builtin_arm_ldc
.param_str = "vUIiUIivC*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_ldc2
.param_str = "vUIiUIivC*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_ldc2l
.param_str = "vUIiUIivC*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_ldcl
.param_str = "vUIiUIivC*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_ldrex
.param_str = "v."
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .custom_typecheck = true }
__builtin_arm_ldrexd
.param_str = "LLUiv*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_mcr
.param_str = "vUIiUIiUiUIiUIiUIi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_mcr2
.param_str = "vUIiUIiUiUIiUIiUIi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_mcrr
.param_str = "vUIiUIiLLUiUIi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_mcrr2
.param_str = "vUIiUIiLLUiUIi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_mrc
.param_str = "UiUIiUIiUIiUIiUIi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_mrc2
.param_str = "UiUIiUIiUIiUIiUIi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_mrrc
.param_str = "LLUiUIiUIiUIi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_mrrc2
.param_str = "LLUiUIiUIiUIi"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_nop
.param_str = "v"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__builtin_arm_prefetch
.param_str = "!"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_qadd
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_qadd16
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_qadd8
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_qasx
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_qdbl
.param_str = "ii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_qsax
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_qsub
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_qsub16
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_qsub8
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_rbit
.param_str = "UiUi"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_rbit64
.param_str = "WUiWUi"
.target_set = TargetSet.initOne(.aarch64)
.attributes = .{ .@"const" = true }
__builtin_arm_rsr
.param_str = "UicC*"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_rsr64
.param_str = "!"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_rsrp
.param_str = "v*cC*"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_sadd16
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_sadd8
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_sasx
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_sel
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_set_fpscr
.param_str = "vUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_sev
.param_str = "v"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__builtin_arm_sevl
.param_str = "v"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__builtin_arm_shadd16
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_shadd8
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_shasx
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_shsax
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_shsub16
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_shsub8
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlabb
.param_str = "iiii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlabt
.param_str = "iiii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlad
.param_str = "iiii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smladx
.param_str = "iiii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlald
.param_str = "LLiiiLLi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlaldx
.param_str = "LLiiiLLi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlatb
.param_str = "iiii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlatt
.param_str = "iiii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlawb
.param_str = "iiii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlawt
.param_str = "iiii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlsd
.param_str = "iiii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlsdx
.param_str = "iiii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlsld
.param_str = "LLiiiLLi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smlsldx
.param_str = "LLiiiLLi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smuad
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smuadx
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smulbb
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smulbt
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smultb
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smultt
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smulwb
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smulwt
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smusd
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_smusdx
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_ssat
.param_str = "iiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_ssat16
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_ssax
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_ssub16
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_ssub8
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_stc
.param_str = "vUIiUIiv*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_stc2
.param_str = "vUIiUIiv*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_stc2l
.param_str = "vUIiUIiv*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_stcl
.param_str = "vUIiUIiv*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_stlex
.param_str = "i."
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .custom_typecheck = true }
__builtin_arm_strex
.param_str = "i."
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .custom_typecheck = true }
__builtin_arm_strexd
.param_str = "iLLUiv*"
.target_set = TargetSet.initOne(.arm)
__builtin_arm_sxtab16
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_sxtb16
.param_str = "ii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_tcancel
.param_str = "vWUIi"
.target_set = TargetSet.initOne(.aarch64)
__builtin_arm_tcommit
.param_str = "v"
.target_set = TargetSet.initOne(.aarch64)
__builtin_arm_tstart
.param_str = "WUi"
.target_set = TargetSet.initOne(.aarch64)
.attributes = .{ .returns_twice = true }
__builtin_arm_ttest
.param_str = "WUi"
.target_set = TargetSet.initOne(.aarch64)
.attributes = .{ .@"const" = true }
__builtin_arm_uadd16
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uadd8
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uasx
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uhadd16
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uhadd8
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uhasx
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uhsax
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uhsub16
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uhsub8
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uqadd16
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uqadd8
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uqasx
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uqsax
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uqsub16
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uqsub8
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_usad8
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_usada8
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_usat
.param_str = "UiiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_usat16
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_usax
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_usub16
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_usub8
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uxtab16
.param_str = "iii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_uxtb16
.param_str = "ii"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_vcvtr_d
.param_str = "fdi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_vcvtr_f
.param_str = "ffi"
.target_set = TargetSet.initOne(.arm)
.attributes = .{ .@"const" = true }
__builtin_arm_wfe
.param_str = "v"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__builtin_arm_wfi
.param_str = "v"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__builtin_arm_wsr
.param_str = "vcC*Ui"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_wsr64
.param_str = "!"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_wsrp
.param_str = "vcC*vC*"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_arm_yield
.param_str = "v"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__builtin_asin
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_asinf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_asinf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_asinh
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_asinhf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_asinhf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_asinhl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_asinl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_assume
.param_str = "vb"
.attributes = .{ .const_evaluable = true }
__builtin_assume_aligned
.param_str = "v*vC*z."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .const_evaluable = true }
__builtin_assume_separate_storage
.param_str = "vvCD*vCD*"
.attributes = .{ .const_evaluable = true }
__builtin_atan
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atan2
.param_str = "ddd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atan2f
.param_str = "fff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atan2f128
.param_str = "LLdLLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atan2l
.param_str = "LdLdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atanf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atanf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atanh
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atanhf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atanhf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atanhl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_atanl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_bcmp
.param_str = "ivC*vC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_bcopy
.param_str = "vvC*v*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_bitrev
.param_str = "UiUi"
.target_set = TargetSet.initOne(.xcore)
.attributes = .{ .@"const" = true }
__builtin_bitreverse16
.param_str = "UsUs"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_bitreverse32
.param_str = "UZiUZi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_bitreverse64
.param_str = "UWiUWi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_bitreverse8
.param_str = "UcUc"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_bswap16
.param_str = "UsUs"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_bswap32
.param_str = "UZiUZi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_bswap64
.param_str = "UWiUWi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_bzero
.param_str = "vv*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_cabs
.param_str = "dXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cabsf
.param_str = "fXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cabsl
.param_str = "LdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cacos
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cacosf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cacosh
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cacoshf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cacoshl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cacosl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_call_with_static_chain
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__builtin_calloc
.param_str = "v*zz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_canonicalize
.param_str = "dd"
.attributes = .{ .@"const" = true }
__builtin_canonicalizef
.param_str = "ff"
.attributes = .{ .@"const" = true }
__builtin_canonicalizef16
.param_str = "hh"
.attributes = .{ .@"const" = true }
__builtin_canonicalizel
.param_str = "LdLd"
.attributes = .{ .@"const" = true }
__builtin_carg
.param_str = "dXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cargf
.param_str = "fXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cargl
.param_str = "LdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_casin
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_casinf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_casinh
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_casinhf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_casinhl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_casinl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_catan
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_catanf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_catanh
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_catanhf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_catanhl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_catanl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cbrt
.param_str = "dd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_cbrtf
.param_str = "ff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_cbrtf128
.param_str = "LLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_cbrtl
.param_str = "LdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_ccos
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ccosf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ccosh
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ccoshf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ccoshl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ccosl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ceil
.param_str = "dd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_ceilf
.param_str = "ff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_ceilf128
.param_str = "LLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_ceilf16
.param_str = "hh"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_ceill
.param_str = "LdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_cexp
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cexpf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cexpl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_char_memchr
.param_str = "c*cC*iz"
.attributes = .{ .const_evaluable = true }
__builtin_cimag
.param_str = "dXd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_cimagf
.param_str = "fXf"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_cimagl
.param_str = "LdXLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_classify_type
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .eval_args = false, .const_evaluable = true }
__builtin_clog
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_clogf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_clogl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_clrsb
.param_str = "ii"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_clrsbl
.param_str = "iLi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_clrsbll
.param_str = "iLLi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_clz
.param_str = "iUi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_clzl
.param_str = "iULi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_clzll
.param_str = "iULLi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_clzs
.param_str = "iUs"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_complex
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .const_evaluable = true }
__builtin_conj
.param_str = "XdXd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_conjf
.param_str = "XfXf"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_conjl
.param_str = "XLdXLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_constant_p
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .eval_args = false, .const_evaluable = true }
__builtin_convertvector
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_copysign
.param_str = "ddd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_copysignf
.param_str = "fff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_copysignf128
.param_str = "LLdLLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_copysignf16
.param_str = "hhh"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_copysignl
.param_str = "LdLdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_cos
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cosf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cosf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cosf16
.param_str = "hh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cosh
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_coshf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_coshf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_coshl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cosl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cpow
.param_str = "XdXdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cpowf
.param_str = "XfXfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cpowl
.param_str = "XLdXLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_cproj
.param_str = "XdXd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_cprojf
.param_str = "XfXf"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_cprojl
.param_str = "XLdXLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_cpu_init
.param_str = "v"
.target_set = TargetSet.initOne(.x86)
__builtin_cpu_is
.param_str = "bcC*"
.target_set = TargetSet.initOne(.x86)
.attributes = .{ .@"const" = true }
__builtin_cpu_supports
.param_str = "bcC*"
.target_set = TargetSet.initOne(.x86)
.attributes = .{ .@"const" = true }
__builtin_creal
.param_str = "dXd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_crealf
.param_str = "fXf"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_creall
.param_str = "LdXLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_csin
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_csinf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_csinh
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_csinhf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_csinhl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_csinl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_csqrt
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_csqrtf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_csqrtl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ctan
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ctanf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ctanh
.param_str = "XdXd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ctanhf
.param_str = "XfXf"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ctanhl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ctanl
.param_str = "XLdXLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ctz
.param_str = "iUi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_ctzl
.param_str = "iULi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_ctzll
.param_str = "iULLi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_ctzs
.param_str = "iUs"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_dcbf
.param_str = "vvC*"
.target_set = TargetSet.initOne(.ppc)
__builtin_debugtrap
.param_str = "v"
__builtin_dump_struct
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__builtin_dwarf_cfa
.param_str = "v*"
__builtin_dwarf_sp_column
.param_str = "Ui"
__builtin_dynamic_object_size
.param_str = "zvC*i"
.attributes = .{ .eval_args = false, .const_evaluable = true }
__builtin_eh_return
.param_str = "vzv*"
.attributes = .{ .noreturn = true }
__builtin_eh_return_data_regno
.param_str = "iIi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_elementwise_abs
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_add_sat
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_bitreverse
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_canonicalize
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_ceil
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_copysign
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_cos
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_exp
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_exp2
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_floor
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_fma
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_log
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_log10
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_log2
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_max
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_min
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_nearbyint
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_pow
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_rint
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_round
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_roundeven
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_sin
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_sqrt
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_sub_sat
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_elementwise_trunc
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_erf
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_erfc
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_erfcf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_erfcf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_erfcl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_erff
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_erff128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_erfl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp10
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp10f
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp10f128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp10f16
.param_str = "hh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp10l
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp2
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp2f
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp2f128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp2f16
.param_str = "hh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_exp2l
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_expect
.param_str = "LiLiLi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_expect_with_probability
.param_str = "LiLiLid"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_expf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_expf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_expf16
.param_str = "hh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_expl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_expm1
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_expm1f
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_expm1f128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_expm1l
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_extend_pointer
.param_str = "ULLiv*"
__builtin_extract_return_addr
.param_str = "v*v*"
__builtin_fabs
.param_str = "dd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fabsf
.param_str = "ff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fabsf128
.param_str = "LLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fabsf16
.param_str = "hh"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_fabsl
.param_str = "LdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fdim
.param_str = "ddd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fdimf
.param_str = "fff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fdimf128
.param_str = "LLdLLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fdiml
.param_str = "LdLdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ffs
.param_str = "ii"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_ffsl
.param_str = "iLi"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_ffsll
.param_str = "iLLi"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_floor
.param_str = "dd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_floorf
.param_str = "ff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_floorf128
.param_str = "LLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_floorf16
.param_str = "hh"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_floorl
.param_str = "LdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_flt_rounds
.param_str = "i"
__builtin_fma
.param_str = "dddd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fmaf
.param_str = "ffff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fmaf128
.param_str = "LLdLLdLLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fmaf16
.param_str = "hhhh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fmal
.param_str = "LdLdLdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fmax
.param_str = "ddd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fmaxf
.param_str = "fff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fmaxf128
.param_str = "LLdLLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fmaxf16
.param_str = "hhh"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fmaxl
.param_str = "LdLdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fmin
.param_str = "ddd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fminf
.param_str = "fff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fminf128
.param_str = "LLdLLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fminf16
.param_str = "hhh"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fminl
.param_str = "LdLdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fmod
.param_str = "ddd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fmodf
.param_str = "fff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fmodf128
.param_str = "LLdLLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fmodf16
.param_str = "hhh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fmodl
.param_str = "LdLdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_fpclassify
.param_str = "iiiiii."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_fprintf
.param_str = "iP*RcC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .printf, .format_string_position = 1 }
__builtin_frame_address
.param_str = "v*IUi"
__builtin_free
.param_str = "vv*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_frexp
.param_str = "ddi*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_frexpf
.param_str = "ffi*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_frexpf128
.param_str = "LLdLLdi*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_frexpf16
.param_str = "hhi*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_frexpl
.param_str = "LdLdi*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_frob_return_addr
.param_str = "v*v*"
__builtin_fscanf
.param_str = "iP*RcC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .scanf, .format_string_position = 1 }
__builtin_getid
.param_str = "Si"
.target_set = TargetSet.initOne(.xcore)
.attributes = .{ .@"const" = true }
__builtin_getps
.param_str = "UiUi"
.target_set = TargetSet.initOne(.xcore)
__builtin_huge_val
.param_str = "d"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_huge_valf
.param_str = "f"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_huge_valf128
.param_str = "LLd"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_huge_valf16
.param_str = "x"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_huge_vall
.param_str = "Ld"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_hypot
.param_str = "ddd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_hypotf
.param_str = "fff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_hypotf128
.param_str = "LLdLLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_hypotl
.param_str = "LdLdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ia32_rdpmc
.param_str = "UOii"
.target_set = TargetSet.initOne(.x86)
__builtin_ia32_rdtsc
.param_str = "UOi"
.target_set = TargetSet.initOne(.x86)
__builtin_ia32_rdtscp
.param_str = "UOiUi*"
.target_set = TargetSet.initOne(.x86)
__builtin_ilogb
.param_str = "id"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ilogbf
.param_str = "if"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ilogbf128
.param_str = "iLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ilogbl
.param_str = "iLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_index
.param_str = "c*cC*i"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_inf
.param_str = "d"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_inff
.param_str = "f"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_inff128
.param_str = "LLd"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_inff16
.param_str = "x"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_infl
.param_str = "Ld"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_init_dwarf_reg_size_table
.param_str = "vv*"
__builtin_is_aligned
.param_str = "bvC*z"
.attributes = .{ .@"const" = true, .custom_typecheck = true, .const_evaluable = true }
__builtin_isfinite
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_isfpclass
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .const_evaluable = true }
__builtin_isgreater
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true }
__builtin_isgreaterequal
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true }
__builtin_isinf
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_isinf_sign
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_isless
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true }
__builtin_islessequal
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true }
__builtin_islessgreater
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true }
__builtin_isnan
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_isnormal
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_isunordered
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true }
__builtin_labs
.param_str = "LiLi"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_launder
.param_str = "v*v*"
.attributes = .{ .custom_typecheck = true, .const_evaluable = true }
__builtin_ldexp
.param_str = "ddi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ldexpf
.param_str = "ffi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ldexpf128
.param_str = "LLdLLdi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ldexpf16
.param_str = "hhi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ldexpl
.param_str = "LdLdi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_lgamma
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_lgammaf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_lgammaf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_lgammal
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_llabs
.param_str = "LLiLLi"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_llrint
.param_str = "LLid"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_llrintf
.param_str = "LLif"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_llrintf128
.param_str = "LLiLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_llrintl
.param_str = "LLiLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_llround
.param_str = "LLid"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_llroundf
.param_str = "LLif"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_llroundf128
.param_str = "LLiLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_llroundl
.param_str = "LLiLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log10
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log10f
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log10f128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log10f16
.param_str = "hh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log10l
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log1p
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log1pf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log1pf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log1pl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log2
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log2f
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log2f128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log2f16
.param_str = "hh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_log2l
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_logb
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_logbf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_logbf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_logbl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_logf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_logf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_logf16
.param_str = "hh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_logl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_longjmp
.param_str = "vv**i"
.attributes = .{ .noreturn = true }
__builtin_lrint
.param_str = "Lid"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_lrintf
.param_str = "Lif"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_lrintf128
.param_str = "LiLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_lrintl
.param_str = "LiLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_lround
.param_str = "Lid"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_lroundf
.param_str = "Lif"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_lroundf128
.param_str = "LiLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_lroundl
.param_str = "LiLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_malloc
.param_str = "v*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_matrix_column_major_load
.param_str = "v."
.attributes = .{ .custom_typecheck = true, .lib_function_with_builtin_prefix = true }
__builtin_matrix_column_major_store
.param_str = "v."
.attributes = .{ .custom_typecheck = true, .lib_function_with_builtin_prefix = true }
__builtin_matrix_transpose
.param_str = "v."
.attributes = .{ .custom_typecheck = true, .lib_function_with_builtin_prefix = true }
__builtin_memchr
.param_str = "v*vC*iz"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_memcmp
.param_str = "ivC*vC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_memcpy
.param_str = "v*v*vC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_memcpy_inline
.param_str = "vv*vC*Iz"
__builtin_memmove
.param_str = "v*v*vC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_mempcpy
.param_str = "v*v*vC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_memset
.param_str = "v*v*iz"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_memset_inline
.param_str = "vv*iIz"
__builtin_mips_absq_s_ph
.param_str = "V2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_absq_s_qb
.param_str = "V4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_absq_s_w
.param_str = "ii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_addq_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_addq_s_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_addq_s_w
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_addqh_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_addqh_r_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_addqh_r_w
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_addqh_w
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_addsc
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_addu_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_addu_qb
.param_str = "V4ScV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_addu_s_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_addu_s_qb
.param_str = "V4ScV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_adduh_qb
.param_str = "V4ScV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_adduh_r_qb
.param_str = "V4ScV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_addwc
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_append
.param_str = "iiiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_balign
.param_str = "iiiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_bitrev
.param_str = "ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_bposge32
.param_str = "i"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmp_eq_ph
.param_str = "vV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmp_le_ph
.param_str = "vV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmp_lt_ph
.param_str = "vV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmpgdu_eq_qb
.param_str = "iV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmpgdu_le_qb
.param_str = "iV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmpgdu_lt_qb
.param_str = "iV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmpgu_eq_qb
.param_str = "iV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmpgu_le_qb
.param_str = "iV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmpgu_lt_qb
.param_str = "iV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmpu_eq_qb
.param_str = "vV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmpu_le_qb
.param_str = "vV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_cmpu_lt_qb
.param_str = "vV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_dpa_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_dpaq_s_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_dpaq_sa_l_w
.param_str = "LLiLLiii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_dpaqx_s_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_dpaqx_sa_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_dpau_h_qbl
.param_str = "LLiLLiV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_dpau_h_qbr
.param_str = "LLiLLiV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_dpax_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_dps_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_dpsq_s_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_dpsq_sa_l_w
.param_str = "LLiLLiii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_dpsqx_s_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_dpsqx_sa_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_dpsu_h_qbl
.param_str = "LLiLLiV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_dpsu_h_qbr
.param_str = "LLiLLiV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_dpsx_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_extp
.param_str = "iLLii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_extpdp
.param_str = "iLLii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_extr_r_w
.param_str = "iLLii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_extr_rs_w
.param_str = "iLLii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_extr_s_h
.param_str = "iLLii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_extr_w
.param_str = "iLLii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_insv
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_lbux
.param_str = "iv*i"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_lhx
.param_str = "iv*i"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_lwx
.param_str = "iv*i"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_madd
.param_str = "LLiLLiii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_maddu
.param_str = "LLiLLiUiUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_maq_s_w_phl
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_maq_s_w_phr
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_maq_sa_w_phl
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_maq_sa_w_phr
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_modsub
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_msub
.param_str = "LLiLLiii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_msubu
.param_str = "LLiLLiUiUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_mthlip
.param_str = "LLiLLii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_mul_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_mul_s_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_muleq_s_w_phl
.param_str = "iV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_muleq_s_w_phr
.param_str = "iV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_muleu_s_ph_qbl
.param_str = "V2sV4ScV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_muleu_s_ph_qbr
.param_str = "V2sV4ScV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_mulq_rs_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_mulq_rs_w
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_mulq_s_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_mulq_s_w
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_mulsa_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_mulsaq_s_w_ph
.param_str = "LLiLLiV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_mult
.param_str = "LLiii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_multu
.param_str = "LLiUiUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_packrl_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_pick_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_pick_qb
.param_str = "V4ScV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_preceq_w_phl
.param_str = "iV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_preceq_w_phr
.param_str = "iV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_precequ_ph_qbl
.param_str = "V2sV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_precequ_ph_qbla
.param_str = "V2sV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_precequ_ph_qbr
.param_str = "V2sV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_precequ_ph_qbra
.param_str = "V2sV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_preceu_ph_qbl
.param_str = "V2sV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_preceu_ph_qbla
.param_str = "V2sV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_preceu_ph_qbr
.param_str = "V2sV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_preceu_ph_qbra
.param_str = "V2sV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_precr_qb_ph
.param_str = "V4ScV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_precr_sra_ph_w
.param_str = "V2siiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_precr_sra_r_ph_w
.param_str = "V2siiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_precrq_ph_w
.param_str = "V2sii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_precrq_qb_ph
.param_str = "V4ScV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_precrq_rs_ph_w
.param_str = "V2sii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_precrqu_s_qb_ph
.param_str = "V4ScV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_prepend
.param_str = "iiiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_raddu_w_qb
.param_str = "iV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_rddsp
.param_str = "iIi"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_repl_ph
.param_str = "V2si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_repl_qb
.param_str = "V4Sci"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_shilo
.param_str = "LLiLLii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_shll_ph
.param_str = "V2sV2si"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_shll_qb
.param_str = "V4ScV4Sci"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_shll_s_ph
.param_str = "V2sV2si"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_shll_s_w
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_shra_ph
.param_str = "V2sV2si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_shra_qb
.param_str = "V4ScV4Sci"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_shra_r_ph
.param_str = "V2sV2si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_shra_r_qb
.param_str = "V4ScV4Sci"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_shra_r_w
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_shrl_ph
.param_str = "V2sV2si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_shrl_qb
.param_str = "V4ScV4Sci"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_subq_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_subq_s_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_subq_s_w
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_subqh_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_subqh_r_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_subqh_r_w
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_subqh_w
.param_str = "iii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_subu_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_subu_qb
.param_str = "V4ScV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_subu_s_ph
.param_str = "V2sV2sV2s"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_subu_s_qb
.param_str = "V4ScV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
__builtin_mips_subuh_qb
.param_str = "V4ScV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_subuh_r_qb
.param_str = "V4ScV4ScV4Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mips_wrdsp
.param_str = "viIi"
.target_set = TargetSet.initOne(.mips)
__builtin_modf
.param_str = "ddd*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_modff
.param_str = "fff*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_modff128
.param_str = "LLdLLdLLd*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_modfl
.param_str = "LdLdLd*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_msa_add_a_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_add_a_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_add_a_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_add_a_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_a_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_a_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_a_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_a_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_u_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_u_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_u_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_adds_u_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_addv_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_addv_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_addv_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_addv_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_addvi_b
.param_str = "V16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_addvi_d
.param_str = "V2LLiV2LLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_addvi_h
.param_str = "V8sV8sIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_addvi_w
.param_str = "V4iV4iIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_and_v
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_andi_b
.param_str = "V16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_asub_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_asub_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_asub_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_asub_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_asub_u_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_asub_u_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_asub_u_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_asub_u_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ave_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ave_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ave_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ave_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ave_u_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ave_u_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ave_u_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ave_u_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_aver_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_aver_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_aver_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_aver_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_aver_u_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_aver_u_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_aver_u_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_aver_u_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bclr_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bclr_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bclr_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bclr_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bclri_b
.param_str = "V16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bclri_d
.param_str = "V2ULLiV2ULLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bclri_h
.param_str = "V8UsV8UsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bclri_w
.param_str = "V4UiV4UiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsl_b
.param_str = "V16UcV16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsl_d
.param_str = "V2ULLiV2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsl_h
.param_str = "V8UsV8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsl_w
.param_str = "V4UiV4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsli_b
.param_str = "V16UcV16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsli_d
.param_str = "V2ULLiV2ULLiV2ULLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsli_h
.param_str = "V8UsV8UsV8UsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsli_w
.param_str = "V4UiV4UiV4UiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsr_b
.param_str = "V16UcV16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsr_d
.param_str = "V2ULLiV2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsr_h
.param_str = "V8UsV8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsr_w
.param_str = "V4UiV4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsri_b
.param_str = "V16UcV16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsri_d
.param_str = "V2ULLiV2ULLiV2ULLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsri_h
.param_str = "V8UsV8UsV8UsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_binsri_w
.param_str = "V4UiV4UiV4UiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bmnz_v
.param_str = "V16UcV16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bmnzi_b
.param_str = "V16UcV16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bmz_v
.param_str = "V16UcV16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bmzi_b
.param_str = "V16UcV16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bneg_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bneg_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bneg_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bneg_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bnegi_b
.param_str = "V16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bnegi_d
.param_str = "V2ULLiV2ULLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bnegi_h
.param_str = "V8UsV8UsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bnegi_w
.param_str = "V4UiV4UiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bnz_b
.param_str = "iV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bnz_d
.param_str = "iV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bnz_h
.param_str = "iV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bnz_v
.param_str = "iV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bnz_w
.param_str = "iV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bsel_v
.param_str = "V16UcV16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bseli_b
.param_str = "V16UcV16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bset_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bset_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bset_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bset_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bseti_b
.param_str = "V16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bseti_d
.param_str = "V2ULLiV2ULLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bseti_h
.param_str = "V8UsV8UsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bseti_w
.param_str = "V4UiV4UiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bz_b
.param_str = "iV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bz_d
.param_str = "iV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bz_h
.param_str = "iV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bz_v
.param_str = "iV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_bz_w
.param_str = "iV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ceq_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ceq_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ceq_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ceq_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ceqi_b
.param_str = "V16ScV16ScISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ceqi_d
.param_str = "V2SLLiV2SLLiISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ceqi_h
.param_str = "V8SsV8SsISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ceqi_w
.param_str = "V4SiV4SiISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_cfcmsa
.param_str = "iIi"
.target_set = TargetSet.initOne(.mips)
__builtin_msa_cle_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_cle_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_cle_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_cle_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_cle_u_b
.param_str = "V16ScV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_cle_u_d
.param_str = "V2SLLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_cle_u_h
.param_str = "V8SsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_cle_u_w
.param_str = "V4SiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clei_s_b
.param_str = "V16ScV16ScISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clei_s_d
.param_str = "V2SLLiV2SLLiISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clei_s_h
.param_str = "V8SsV8SsISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clei_s_w
.param_str = "V4SiV4SiISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clei_u_b
.param_str = "V16ScV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clei_u_d
.param_str = "V2SLLiV2ULLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clei_u_h
.param_str = "V8SsV8UsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clei_u_w
.param_str = "V4SiV4UiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clt_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clt_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clt_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clt_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clt_u_b
.param_str = "V16ScV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clt_u_d
.param_str = "V2SLLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clt_u_h
.param_str = "V8SsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clt_u_w
.param_str = "V4SiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clti_s_b
.param_str = "V16ScV16ScISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clti_s_d
.param_str = "V2SLLiV2SLLiISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clti_s_h
.param_str = "V8SsV8SsISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clti_s_w
.param_str = "V4SiV4SiISi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clti_u_b
.param_str = "V16ScV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clti_u_d
.param_str = "V2SLLiV2ULLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clti_u_h
.param_str = "V8SsV8UsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_clti_u_w
.param_str = "V4SiV4UiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_copy_s_b
.param_str = "iV16ScIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_copy_s_d
.param_str = "LLiV2SLLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_copy_s_h
.param_str = "iV8SsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_copy_s_w
.param_str = "iV4SiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_copy_u_b
.param_str = "iV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_copy_u_d
.param_str = "LLiV2ULLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_copy_u_h
.param_str = "iV8UsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_copy_u_w
.param_str = "iV4UiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ctcmsa
.param_str = "vIii"
.target_set = TargetSet.initOne(.mips)
__builtin_msa_div_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_div_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_div_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_div_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_div_u_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_div_u_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_div_u_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_div_u_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dotp_s_d
.param_str = "V2SLLiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dotp_s_h
.param_str = "V8SsV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dotp_s_w
.param_str = "V4SiV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dotp_u_d
.param_str = "V2ULLiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dotp_u_h
.param_str = "V8UsV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dotp_u_w
.param_str = "V4UiV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpadd_s_d
.param_str = "V2SLLiV2SLLiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpadd_s_h
.param_str = "V8SsV8SsV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpadd_s_w
.param_str = "V4SiV4SiV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpadd_u_d
.param_str = "V2ULLiV2ULLiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpadd_u_h
.param_str = "V8UsV8UsV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpadd_u_w
.param_str = "V4UiV4UiV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpsub_s_d
.param_str = "V2SLLiV2SLLiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpsub_s_h
.param_str = "V8SsV8SsV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpsub_s_w
.param_str = "V4SiV4SiV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpsub_u_d
.param_str = "V2ULLiV2ULLiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpsub_u_h
.param_str = "V8UsV8UsV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_dpsub_u_w
.param_str = "V4UiV4UiV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fadd_d
.param_str = "V2dV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fadd_w
.param_str = "V4fV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcaf_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcaf_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fceq_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fceq_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fclass_d
.param_str = "V2LLiV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fclass_w
.param_str = "V4iV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcle_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcle_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fclt_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fclt_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcne_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcne_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcor_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcor_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcueq_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcueq_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcule_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcule_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcult_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcult_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcun_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcun_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcune_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fcune_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fdiv_d
.param_str = "V2dV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fdiv_w
.param_str = "V4fV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fexdo_h
.param_str = "V8hV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fexdo_w
.param_str = "V4fV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fexp2_d
.param_str = "V2dV2dV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fexp2_w
.param_str = "V4fV4fV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fexupl_d
.param_str = "V2dV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fexupl_w
.param_str = "V4fV8h"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fexupr_d
.param_str = "V2dV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fexupr_w
.param_str = "V4fV8h"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ffint_s_d
.param_str = "V2dV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ffint_s_w
.param_str = "V4fV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ffint_u_d
.param_str = "V2dV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ffint_u_w
.param_str = "V4fV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ffql_d
.param_str = "V2dV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ffql_w
.param_str = "V4fV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ffqr_d
.param_str = "V2dV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ffqr_w
.param_str = "V4fV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fill_b
.param_str = "V16Sci"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fill_d
.param_str = "V2SLLiLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fill_h
.param_str = "V8Ssi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fill_w
.param_str = "V4Sii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_flog2_d
.param_str = "V2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_flog2_w
.param_str = "V4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmadd_d
.param_str = "V2dV2dV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmadd_w
.param_str = "V4fV4fV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmax_a_d
.param_str = "V2dV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmax_a_w
.param_str = "V4fV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmax_d
.param_str = "V2dV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmax_w
.param_str = "V4fV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmin_a_d
.param_str = "V2dV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmin_a_w
.param_str = "V4fV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmin_d
.param_str = "V2dV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmin_w
.param_str = "V4fV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmsub_d
.param_str = "V2dV2dV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmsub_w
.param_str = "V4fV4fV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmul_d
.param_str = "V2dV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fmul_w
.param_str = "V4fV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_frcp_d
.param_str = "V2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_frcp_w
.param_str = "V4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_frint_d
.param_str = "V2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_frint_w
.param_str = "V4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_frsqrt_d
.param_str = "V2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_frsqrt_w
.param_str = "V4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsaf_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsaf_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fseq_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fseq_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsle_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsle_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fslt_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fslt_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsne_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsne_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsor_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsor_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsqrt_d
.param_str = "V2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsqrt_w
.param_str = "V4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsub_d
.param_str = "V2dV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsub_w
.param_str = "V4fV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsueq_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsueq_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsule_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsule_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsult_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsult_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsun_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsun_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsune_d
.param_str = "V2LLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_fsune_w
.param_str = "V4iV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ftint_s_d
.param_str = "V2SLLiV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ftint_s_w
.param_str = "V4SiV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ftint_u_d
.param_str = "V2ULLiV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ftint_u_w
.param_str = "V4UiV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ftq_h
.param_str = "V4UiV4fV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ftq_w
.param_str = "V2ULLiV2dV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ftrunc_s_d
.param_str = "V2SLLiV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ftrunc_s_w
.param_str = "V4SiV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ftrunc_u_d
.param_str = "V2ULLiV2d"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ftrunc_u_w
.param_str = "V4UiV4f"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hadd_s_d
.param_str = "V2SLLiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hadd_s_h
.param_str = "V8SsV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hadd_s_w
.param_str = "V4SiV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hadd_u_d
.param_str = "V2ULLiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hadd_u_h
.param_str = "V8UsV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hadd_u_w
.param_str = "V4UiV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hsub_s_d
.param_str = "V2SLLiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hsub_s_h
.param_str = "V8SsV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hsub_s_w
.param_str = "V4SiV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hsub_u_d
.param_str = "V2ULLiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hsub_u_h
.param_str = "V8UsV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_hsub_u_w
.param_str = "V4UiV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvev_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvev_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvev_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvev_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvl_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvl_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvl_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvl_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvod_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvod_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvod_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvod_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvr_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvr_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvr_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ilvr_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_insert_b
.param_str = "V16ScV16ScIUii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_insert_d
.param_str = "V2SLLiV2SLLiIUiLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_insert_h
.param_str = "V8SsV8SsIUii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_insert_w
.param_str = "V4SiV4SiIUii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_insve_b
.param_str = "V16ScV16ScIUiV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_insve_d
.param_str = "V2SLLiV2SLLiIUiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_insve_h
.param_str = "V8SsV8SsIUiV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_insve_w
.param_str = "V4SiV4SiIUiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ld_b
.param_str = "V16Scv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ld_d
.param_str = "V2SLLiv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ld_h
.param_str = "V8Ssv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ld_w
.param_str = "V4Siv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ldi_b
.param_str = "V16cIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ldi_d
.param_str = "V2LLiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ldi_h
.param_str = "V8sIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ldi_w
.param_str = "V4iIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ldr_d
.param_str = "V2SLLiv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ldr_w
.param_str = "V4Siv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_madd_q_h
.param_str = "V8SsV8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_madd_q_w
.param_str = "V4SiV4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maddr_q_h
.param_str = "V8SsV8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maddr_q_w
.param_str = "V4SiV4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maddv_b
.param_str = "V16ScV16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maddv_d
.param_str = "V2SLLiV2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maddv_h
.param_str = "V8SsV8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maddv_w
.param_str = "V4SiV4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_a_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_a_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_a_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_a_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_u_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_u_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_u_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_max_u_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maxi_s_b
.param_str = "V16ScV16ScIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maxi_s_d
.param_str = "V2SLLiV2SLLiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maxi_s_h
.param_str = "V8SsV8SsIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maxi_s_w
.param_str = "V4SiV4SiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maxi_u_b
.param_str = "V16UcV16UcIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maxi_u_d
.param_str = "V2ULLiV2ULLiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maxi_u_h
.param_str = "V8UsV8UsIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_maxi_u_w
.param_str = "V4UiV4UiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_a_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_a_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_a_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_a_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_u_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_u_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_u_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_min_u_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mini_s_b
.param_str = "V16ScV16ScIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mini_s_d
.param_str = "V2SLLiV2SLLiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mini_s_h
.param_str = "V8SsV8SsIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mini_s_w
.param_str = "V4SiV4SiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mini_u_b
.param_str = "V16UcV16UcIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mini_u_d
.param_str = "V2ULLiV2ULLiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mini_u_h
.param_str = "V8UsV8UsIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mini_u_w
.param_str = "V4UiV4UiIi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mod_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mod_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mod_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mod_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mod_u_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mod_u_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mod_u_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mod_u_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_move_v
.param_str = "V16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_msub_q_h
.param_str = "V8SsV8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_msub_q_w
.param_str = "V4SiV4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_msubr_q_h
.param_str = "V8SsV8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_msubr_q_w
.param_str = "V4SiV4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_msubv_b
.param_str = "V16ScV16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_msubv_d
.param_str = "V2SLLiV2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_msubv_h
.param_str = "V8SsV8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_msubv_w
.param_str = "V4SiV4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mul_q_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mul_q_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mulr_q_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mulr_q_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mulv_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mulv_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mulv_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_mulv_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_nloc_b
.param_str = "V16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_nloc_d
.param_str = "V2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_nloc_h
.param_str = "V8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_nloc_w
.param_str = "V4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_nlzc_b
.param_str = "V16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_nlzc_d
.param_str = "V2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_nlzc_h
.param_str = "V8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_nlzc_w
.param_str = "V4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_nor_v
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_nori_b
.param_str = "V16UcV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_or_v
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_ori_b
.param_str = "V16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pckev_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pckev_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pckev_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pckev_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pckod_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pckod_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pckod_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pckod_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pcnt_b
.param_str = "V16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pcnt_d
.param_str = "V2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pcnt_h
.param_str = "V8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_pcnt_w
.param_str = "V4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sat_s_b
.param_str = "V16ScV16ScIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sat_s_d
.param_str = "V2SLLiV2SLLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sat_s_h
.param_str = "V8SsV8SsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sat_s_w
.param_str = "V4SiV4SiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sat_u_b
.param_str = "V16UcV16UcIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sat_u_d
.param_str = "V2ULLiV2ULLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sat_u_h
.param_str = "V8UsV8UsIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sat_u_w
.param_str = "V4UiV4UiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_shf_b
.param_str = "V16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_shf_h
.param_str = "V8sV8sIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_shf_w
.param_str = "V4iV4iIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sld_b
.param_str = "V16cV16cV16cUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sld_d
.param_str = "V2LLiV2LLiV2LLiUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sld_h
.param_str = "V8sV8sV8sUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sld_w
.param_str = "V4iV4iV4iUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sldi_b
.param_str = "V16cV16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sldi_d
.param_str = "V2LLiV2LLiV2LLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sldi_h
.param_str = "V8sV8sV8sIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sldi_w
.param_str = "V4iV4iV4iIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sll_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sll_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sll_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sll_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_slli_b
.param_str = "V16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_slli_d
.param_str = "V2LLiV2LLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_slli_h
.param_str = "V8sV8sIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_slli_w
.param_str = "V4iV4iIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_splat_b
.param_str = "V16cV16cUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_splat_d
.param_str = "V2LLiV2LLiUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_splat_h
.param_str = "V8sV8sUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_splat_w
.param_str = "V4iV4iUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_splati_b
.param_str = "V16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_splati_d
.param_str = "V2LLiV2LLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_splati_h
.param_str = "V8sV8sIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_splati_w
.param_str = "V4iV4iIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sra_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sra_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sra_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_sra_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srai_b
.param_str = "V16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srai_d
.param_str = "V2LLiV2LLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srai_h
.param_str = "V8sV8sIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srai_w
.param_str = "V4iV4iIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srar_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srar_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srar_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srar_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srari_b
.param_str = "V16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srari_d
.param_str = "V2LLiV2LLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srari_h
.param_str = "V8sV8sIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srari_w
.param_str = "V4iV4iIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srl_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srl_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srl_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srl_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srli_b
.param_str = "V16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srli_d
.param_str = "V2LLiV2LLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srli_h
.param_str = "V8sV8sIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srli_w
.param_str = "V4iV4iIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srlr_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srlr_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srlr_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srlr_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srlri_b
.param_str = "V16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srlri_d
.param_str = "V2LLiV2LLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srlri_h
.param_str = "V8sV8sIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_srlri_w
.param_str = "V4iV4iIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_st_b
.param_str = "vV16Scv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_st_d
.param_str = "vV2SLLiv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_st_h
.param_str = "vV8Ssv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_st_w
.param_str = "vV4Siv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_str_d
.param_str = "vV2SLLiv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_str_w
.param_str = "vV4Siv*Ii"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subs_s_b
.param_str = "V16ScV16ScV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subs_s_d
.param_str = "V2SLLiV2SLLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subs_s_h
.param_str = "V8SsV8SsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subs_s_w
.param_str = "V4SiV4SiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subs_u_b
.param_str = "V16UcV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subs_u_d
.param_str = "V2ULLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subs_u_h
.param_str = "V8UsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subs_u_w
.param_str = "V4UiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subsus_u_b
.param_str = "V16UcV16UcV16Sc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subsus_u_d
.param_str = "V2ULLiV2ULLiV2SLLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subsus_u_h
.param_str = "V8UsV8UsV8Ss"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subsus_u_w
.param_str = "V4UiV4UiV4Si"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subsuu_s_b
.param_str = "V16ScV16UcV16Uc"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subsuu_s_d
.param_str = "V2SLLiV2ULLiV2ULLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subsuu_s_h
.param_str = "V8SsV8UsV8Us"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subsuu_s_w
.param_str = "V4SiV4UiV4Ui"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subv_b
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subv_d
.param_str = "V2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subv_h
.param_str = "V8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subv_w
.param_str = "V4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subvi_b
.param_str = "V16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subvi_d
.param_str = "V2LLiV2LLiIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subvi_h
.param_str = "V8sV8sIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_subvi_w
.param_str = "V4iV4iIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_vshf_b
.param_str = "V16cV16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_vshf_d
.param_str = "V2LLiV2LLiV2LLiV2LLi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_vshf_h
.param_str = "V8sV8sV8sV8s"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_vshf_w
.param_str = "V4iV4iV4iV4i"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_xor_v
.param_str = "V16cV16cV16c"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_msa_xori_b
.param_str = "V16cV16cIUi"
.target_set = TargetSet.initOne(.mips)
.attributes = .{ .@"const" = true }
__builtin_mul_overflow
.param_str = "b."
.attributes = .{ .custom_typecheck = true, .const_evaluable = true }
__builtin_nan
.param_str = "dcC*"
.attributes = .{ .pure = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_nanf
.param_str = "fcC*"
.attributes = .{ .pure = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_nanf128
.param_str = "LLdcC*"
.attributes = .{ .pure = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_nanf16
.param_str = "xcC*"
.attributes = .{ .pure = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_nanl
.param_str = "LdcC*"
.attributes = .{ .pure = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_nans
.param_str = "dcC*"
.attributes = .{ .pure = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_nansf
.param_str = "fcC*"
.attributes = .{ .pure = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_nansf128
.param_str = "LLdcC*"
.attributes = .{ .pure = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_nansf16
.param_str = "xcC*"
.attributes = .{ .pure = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_nansl
.param_str = "LdcC*"
.attributes = .{ .pure = true, .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_nearbyint
.param_str = "dd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_nearbyintf
.param_str = "ff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_nearbyintf128
.param_str = "LLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_nearbyintl
.param_str = "LdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_nextafter
.param_str = "ddd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_nextafterf
.param_str = "fff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_nextafterf128
.param_str = "LLdLLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_nextafterl
.param_str = "LdLdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_nexttoward
.param_str = "ddLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_nexttowardf
.param_str = "ffLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_nexttowardf128
.param_str = "LLdLLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_nexttowardl
.param_str = "LdLdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_nondeterministic_value
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__builtin_nontemporal_load
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__builtin_nontemporal_store
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__builtin_objc_memmove_collectable
.param_str = "v*v*vC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_object_size
.param_str = "zvC*i"
.attributes = .{ .eval_args = false, .const_evaluable = true }
__builtin_operator_delete
.param_str = "vv*"
.attributes = .{ .custom_typecheck = true, .const_evaluable = true }
__builtin_operator_new
.param_str = "v*z"
.attributes = .{ .@"const" = true, .custom_typecheck = true, .const_evaluable = true }
__builtin_os_log_format
.param_str = "v*v*cC*."
.attributes = .{ .custom_typecheck = true, .format_kind = .printf }
__builtin_os_log_format_buffer_size
.param_str = "zcC*."
.attributes = .{ .custom_typecheck = true, .format_kind = .printf, .eval_args = false, .const_evaluable = true }
__builtin_pack_longdouble
.param_str = "Lddd"
.target_set = TargetSet.initOne(.ppc)
__builtin_parity
.param_str = "iUi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_parityl
.param_str = "iULi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_parityll
.param_str = "iULLi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_popcount
.param_str = "iUi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_popcountl
.param_str = "iULi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_popcountll
.param_str = "iULLi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_pow
.param_str = "ddd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_powf
.param_str = "fff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_powf128
.param_str = "LLdLLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_powf16
.param_str = "hhh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_powi
.param_str = "ddi"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_powif
.param_str = "ffi"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_powil
.param_str = "LdLdi"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_powl
.param_str = "LdLdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_ppc_alignx
.param_str = "vIivC*"
.target_set = TargetSet.initOne(.ppc)
.attributes = .{ .@"const" = true }
__builtin_ppc_cmpb
.param_str = "LLiLLiLLi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_compare_and_swap
.param_str = "iiD*i*i"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_compare_and_swaplp
.param_str = "iLiD*Li*Li"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_dcbfl
.param_str = "vvC*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_dcbflp
.param_str = "vvC*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_dcbst
.param_str = "vvC*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_dcbt
.param_str = "vv*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_dcbtst
.param_str = "vv*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_dcbtstt
.param_str = "vv*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_dcbtt
.param_str = "vv*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_dcbz
.param_str = "vv*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_eieio
.param_str = "v"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fcfid
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fcfud
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fctid
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fctidz
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fctiw
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fctiwz
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fctudz
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fctuwz
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fetch_and_add
.param_str = "iiD*i"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fetch_and_addlp
.param_str = "LiLiD*Li"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fetch_and_and
.param_str = "UiUiD*Ui"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fetch_and_andlp
.param_str = "ULiULiD*ULi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fetch_and_or
.param_str = "UiUiD*Ui"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fetch_and_orlp
.param_str = "ULiULiD*ULi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fetch_and_swap
.param_str = "UiUiD*Ui"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fetch_and_swaplp
.param_str = "ULiULiD*ULi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fmsub
.param_str = "dddd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fmsubs
.param_str = "ffff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fnabs
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fnabss
.param_str = "ff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fnmadd
.param_str = "dddd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fnmadds
.param_str = "ffff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fnmsub
.param_str = "dddd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fnmsubs
.param_str = "ffff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fre
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fres
.param_str = "ff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fric
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_frim
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_frims
.param_str = "ff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_frin
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_frins
.param_str = "ff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_frip
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_frips
.param_str = "ff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_friz
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_frizs
.param_str = "ff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_frsqrte
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_frsqrtes
.param_str = "ff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fsel
.param_str = "dddd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fsels
.param_str = "ffff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fsqrt
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_fsqrts
.param_str = "ff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_get_timebase
.param_str = "ULLi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_iospace_eieio
.param_str = "v"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_iospace_lwsync
.param_str = "v"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_iospace_sync
.param_str = "v"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_isync
.param_str = "v"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_ldarx
.param_str = "LiLiD*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_load2r
.param_str = "UsUs*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_load4r
.param_str = "UiUi*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_lwarx
.param_str = "iiD*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_lwsync
.param_str = "v"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_maxfe
.param_str = "LdLdLdLd."
.target_set = TargetSet.initOne(.ppc)
.attributes = .{ .custom_typecheck = true }
__builtin_ppc_maxfl
.param_str = "dddd."
.target_set = TargetSet.initOne(.ppc)
.attributes = .{ .custom_typecheck = true }
__builtin_ppc_maxfs
.param_str = "ffff."
.target_set = TargetSet.initOne(.ppc)
.attributes = .{ .custom_typecheck = true }
__builtin_ppc_mfmsr
.param_str = "Ui"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mfspr
.param_str = "ULiIi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mftbu
.param_str = "Ui"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_minfe
.param_str = "LdLdLdLd."
.target_set = TargetSet.initOne(.ppc)
.attributes = .{ .custom_typecheck = true }
__builtin_ppc_minfl
.param_str = "dddd."
.target_set = TargetSet.initOne(.ppc)
.attributes = .{ .custom_typecheck = true }
__builtin_ppc_minfs
.param_str = "ffff."
.target_set = TargetSet.initOne(.ppc)
.attributes = .{ .custom_typecheck = true }
__builtin_ppc_mtfsb0
.param_str = "vUIi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mtfsb1
.param_str = "vUIi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mtfsf
.param_str = "vUIiUi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mtfsfi
.param_str = "vUIiUIi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mtmsr
.param_str = "vUi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mtspr
.param_str = "vIiULi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mulhd
.param_str = "LLiLiLi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mulhdu
.param_str = "ULLiULiULi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mulhw
.param_str = "iii"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_mulhwu
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_popcntb
.param_str = "ULiULi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_poppar4
.param_str = "iUi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_poppar8
.param_str = "iULLi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_rdlam
.param_str = "UWiUWiUWiUWIi"
.target_set = TargetSet.initOne(.ppc)
.attributes = .{ .@"const" = true }
__builtin_ppc_recipdivd
.param_str = "V2dV2dV2d"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_recipdivf
.param_str = "V4fV4fV4f"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_rldimi
.param_str = "ULLiULLiULLiIUiIULLi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_rlwimi
.param_str = "UiUiUiIUiIUi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_rlwnm
.param_str = "UiUiUiIUi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_rsqrtd
.param_str = "V2dV2d"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_rsqrtf
.param_str = "V4fV4f"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_stdcx
.param_str = "iLiD*Li"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_stfiw
.param_str = "viC*d"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_store2r
.param_str = "vUiUs*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_store4r
.param_str = "vUiUi*"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_stwcx
.param_str = "iiD*i"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_swdiv
.param_str = "ddd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_swdiv_nochk
.param_str = "ddd"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_swdivs
.param_str = "fff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_swdivs_nochk
.param_str = "fff"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_sync
.param_str = "v"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_tdw
.param_str = "vLLiLLiIUi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_trap
.param_str = "vi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_trapd
.param_str = "vLi"
.target_set = TargetSet.initOne(.ppc)
__builtin_ppc_tw
.param_str = "viiIUi"
.target_set = TargetSet.initOne(.ppc)
__builtin_prefetch
.param_str = "vvC*."
.attributes = .{ .@"const" = true }
__builtin_preserve_access_index
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__builtin_printf
.param_str = "icC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .printf }
__builtin_ptx_get_image_channel_data_typei_
.param_str = "ii"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_get_image_channel_orderi_
.param_str = "ii"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_get_image_depthi_
.param_str = "ii"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_get_image_heighti_
.param_str = "ii"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_get_image_widthi_
.param_str = "ii"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_read_image2Dff_
.param_str = "V4fiiff"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_read_image2Dfi_
.param_str = "V4fiiii"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_read_image2Dif_
.param_str = "V4iiiff"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_read_image2Dii_
.param_str = "V4iiiii"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_read_image3Dff_
.param_str = "V4fiiffff"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_read_image3Dfi_
.param_str = "V4fiiiiii"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_read_image3Dif_
.param_str = "V4iiiffff"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_read_image3Dii_
.param_str = "V4iiiiiii"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_write_image2Df_
.param_str = "viiiffff"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_write_image2Di_
.param_str = "viiiiiii"
.target_set = TargetSet.initOne(.nvptx)
__builtin_ptx_write_image2Dui_
.param_str = "viiiUiUiUiUi"
.target_set = TargetSet.initOne(.nvptx)
__builtin_r600_implicitarg_ptr
.param_str = "Uc*7"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_r600_read_tgid_x
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_r600_read_tgid_y
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_r600_read_tgid_z
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_r600_read_tidig_x
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_r600_read_tidig_y
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_r600_read_tidig_z
.param_str = "Ui"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_r600_recipsqrt_ieee
.param_str = "dd"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_r600_recipsqrt_ieeef
.param_str = "ff"
.target_set = TargetSet.initOne(.amdgpu)
.attributes = .{ .@"const" = true }
__builtin_readcyclecounter
.param_str = "ULLi"
__builtin_readflm
.param_str = "d"
.target_set = TargetSet.initOne(.ppc)
__builtin_realloc
.param_str = "v*v*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_reduce_add
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_reduce_and
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_reduce_max
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_reduce_min
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_reduce_mul
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_reduce_or
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_reduce_xor
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_remainder
.param_str = "ddd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_remainderf
.param_str = "fff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_remainderf128
.param_str = "LLdLLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_remainderl
.param_str = "LdLdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_remquo
.param_str = "dddi*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_remquof
.param_str = "fffi*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_remquof128
.param_str = "LLdLLdLLdi*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_remquol
.param_str = "LdLdLdi*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_return_address
.param_str = "v*IUi"
__builtin_rindex
.param_str = "c*cC*i"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_rint
.param_str = "dd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_rintf
.param_str = "ff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_rintf128
.param_str = "LLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_rintf16
.param_str = "hh"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_rintl
.param_str = "LdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_rotateleft16
.param_str = "UsUsUs"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_rotateleft32
.param_str = "UZiUZiUZi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_rotateleft64
.param_str = "UWiUWiUWi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_rotateleft8
.param_str = "UcUcUc"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_rotateright16
.param_str = "UsUsUs"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_rotateright32
.param_str = "UZiUZiUZi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_rotateright64
.param_str = "UWiUWiUWi"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_rotateright8
.param_str = "UcUcUc"
.attributes = .{ .@"const" = true, .const_evaluable = true }
__builtin_round
.param_str = "dd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_roundeven
.param_str = "dd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_roundevenf
.param_str = "ff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_roundevenf128
.param_str = "LLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_roundevenf16
.param_str = "hh"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_roundevenl
.param_str = "LdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_roundf
.param_str = "ff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_roundf128
.param_str = "LLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_roundf16
.param_str = "hh"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_roundl
.param_str = "LdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_sadd_overflow
.param_str = "bSiCSiCSi*"
.attributes = .{ .const_evaluable = true }
__builtin_saddl_overflow
.param_str = "bSLiCSLiCSLi*"
.attributes = .{ .const_evaluable = true }
__builtin_saddll_overflow
.param_str = "bSLLiCSLLiCSLLi*"
.attributes = .{ .const_evaluable = true }
__builtin_scalbln
.param_str = "ddLi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_scalblnf
.param_str = "ffLi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_scalblnf128
.param_str = "LLdLLdLi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_scalblnl
.param_str = "LdLdLi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_scalbn
.param_str = "ddi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_scalbnf
.param_str = "ffi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_scalbnf128
.param_str = "LLdLLdi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_scalbnl
.param_str = "LdLdi"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_scanf
.param_str = "icC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .scanf }
__builtin_set_flt_rounds
.param_str = "vi"
__builtin_setflm
.param_str = "dd"
.target_set = TargetSet.initOne(.ppc)
__builtin_setjmp
.param_str = "iv**"
.attributes = .{ .returns_twice = true }
__builtin_setps
.param_str = "vUiUi"
.target_set = TargetSet.initOne(.xcore)
__builtin_setrnd
.param_str = "di"
.target_set = TargetSet.initOne(.ppc)
__builtin_shufflevector
.param_str = "v."
.attributes = .{ .@"const" = true, .custom_typecheck = true }
__builtin_signbit
.param_str = "i."
.attributes = .{ .@"const" = true, .custom_typecheck = true, .lib_function_with_builtin_prefix = true }
__builtin_signbitf
.param_str = "if"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_signbitl
.param_str = "iLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_sin
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sinf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sinf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sinf16
.param_str = "hh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sinh
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sinhf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sinhf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sinhl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sinl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_smul_overflow
.param_str = "bSiCSiCSi*"
.attributes = .{ .const_evaluable = true }
__builtin_smull_overflow
.param_str = "bSLiCSLiCSLi*"
.attributes = .{ .const_evaluable = true }
__builtin_smulll_overflow
.param_str = "bSLLiCSLLiCSLLi*"
.attributes = .{ .const_evaluable = true }
__builtin_snprintf
.param_str = "ic*RzcC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .printf, .format_string_position = 2 }
__builtin_sponentry
.param_str = "v*"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__builtin_sprintf
.param_str = "ic*RcC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .printf, .format_string_position = 1 }
__builtin_sqrt
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sqrtf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sqrtf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sqrtf16
.param_str = "hh"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sqrtl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_sscanf
.param_str = "icC*RcC*R."
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .scanf, .format_string_position = 1 }
__builtin_ssub_overflow
.param_str = "bSiCSiCSi*"
.attributes = .{ .const_evaluable = true }
__builtin_ssubl_overflow
.param_str = "bSLiCSLiCSLi*"
.attributes = .{ .const_evaluable = true }
__builtin_ssubll_overflow
.param_str = "bSLLiCSLLiCSLLi*"
.attributes = .{ .const_evaluable = true }
__builtin_stdarg_start
.param_str = "vA."
.attributes = .{ .custom_typecheck = true }
__builtin_stpcpy
.param_str = "c*c*cC*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_stpncpy
.param_str = "c*c*cC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strcasecmp
.param_str = "icC*cC*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strcat
.param_str = "c*c*cC*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strchr
.param_str = "c*cC*i"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_strcmp
.param_str = "icC*cC*"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_strcpy
.param_str = "c*c*cC*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strcspn
.param_str = "zcC*cC*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strdup
.param_str = "c*cC*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strlen
.param_str = "zcC*"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_strncasecmp
.param_str = "icC*cC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strncat
.param_str = "c*c*cC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strncmp
.param_str = "icC*cC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_strncpy
.param_str = "c*c*cC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strndup
.param_str = "c*cC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strpbrk
.param_str = "c*cC*cC*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strrchr
.param_str = "c*cC*i"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strspn
.param_str = "zcC*cC*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_strstr
.param_str = "c*cC*cC*"
.attributes = .{ .lib_function_with_builtin_prefix = true }
__builtin_sub_overflow
.param_str = "b."
.attributes = .{ .custom_typecheck = true, .const_evaluable = true }
__builtin_subc
.param_str = "UiUiCUiCUiCUi*"
__builtin_subcb
.param_str = "UcUcCUcCUcCUc*"
__builtin_subcl
.param_str = "ULiULiCULiCULiCULi*"
__builtin_subcll
.param_str = "ULLiULLiCULLiCULLiCULLi*"
__builtin_subcs
.param_str = "UsUsCUsCUsCUs*"
__builtin_tan
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tanf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tanf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tanh
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tanhf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tanhf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tanhl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tanl
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tgamma
.param_str = "dd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tgammaf
.param_str = "ff"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tgammaf128
.param_str = "LLdLLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_tgammal
.param_str = "LdLd"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_without_errno_and_fp_exceptions = true }
__builtin_thread_pointer
.param_str = "v*"
.attributes = .{ .@"const" = true }
__builtin_trap
.param_str = "v"
.attributes = .{ .noreturn = true }
__builtin_trunc
.param_str = "dd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_truncf
.param_str = "ff"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_truncf128
.param_str = "LLdLLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_truncf16
.param_str = "hh"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_truncl
.param_str = "LdLd"
.attributes = .{ .@"const" = true, .lib_function_with_builtin_prefix = true }
__builtin_uadd_overflow
.param_str = "bUiCUiCUi*"
.attributes = .{ .const_evaluable = true }
__builtin_uaddl_overflow
.param_str = "bULiCULiCULi*"
.attributes = .{ .const_evaluable = true }
__builtin_uaddll_overflow
.param_str = "bULLiCULLiCULLi*"
.attributes = .{ .const_evaluable = true }
__builtin_umul_overflow
.param_str = "bUiCUiCUi*"
.attributes = .{ .const_evaluable = true }
__builtin_umull_overflow
.param_str = "bULiCULiCULi*"
.attributes = .{ .const_evaluable = true }
__builtin_umulll_overflow
.param_str = "bULLiCULLiCULLi*"
.attributes = .{ .const_evaluable = true }
__builtin_unpack_longdouble
.param_str = "dLdIi"
.target_set = TargetSet.initOne(.ppc)
__builtin_unpredictable
.param_str = "LiLi"
.attributes = .{ .@"const" = true }
__builtin_unreachable
.param_str = "v"
.attributes = .{ .noreturn = true }
__builtin_unwind_init
.param_str = "v"
__builtin_usub_overflow
.param_str = "bUiCUiCUi*"
.attributes = .{ .const_evaluable = true }
__builtin_usubl_overflow
.param_str = "bULiCULiCULi*"
.attributes = .{ .const_evaluable = true }
__builtin_usubll_overflow
.param_str = "bULLiCULLiCULLi*"
.attributes = .{ .const_evaluable = true }
__builtin_va_copy
.param_str = "vAA"
__builtin_va_end
.param_str = "vA"
__builtin_va_start
.param_str = "vA."
.attributes = .{ .custom_typecheck = true }
__builtin_ve_vl_andm_MMM
.param_str = "V512bV512bV512b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_andm_mmm
.param_str = "V256bV256bV256b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_eqvm_MMM
.param_str = "V512bV512bV512b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_eqvm_mmm
.param_str = "V256bV256bV256b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_extract_vm512l
.param_str = "V256bV512b"
.target_set = TargetSet.initOne(.ve)
__builtin_ve_vl_extract_vm512u
.param_str = "V256bV512b"
.target_set = TargetSet.initOne(.ve)
__builtin_ve_vl_fencec_s
.param_str = "vUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_fencei
.param_str = "v"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_fencem_s
.param_str = "vUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_fidcr_sss
.param_str = "LUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_insert_vm512l
.param_str = "V512bV512bV256b"
.target_set = TargetSet.initOne(.ve)
__builtin_ve_vl_insert_vm512u
.param_str = "V512bV512bV256b"
.target_set = TargetSet.initOne(.ve)
__builtin_ve_vl_lcr_sss
.param_str = "LUiLUiLUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_lsv_vvss
.param_str = "V256dV256dUiLUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_lvm_MMss
.param_str = "V512bV512bLUiLUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_lvm_mmss
.param_str = "V256bV256bLUiLUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_lvsd_svs
.param_str = "dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_lvsl_svs
.param_str = "LUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_lvss_svs
.param_str = "fV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_lzvm_sml
.param_str = "LUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_negm_MM
.param_str = "V512bV512b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_negm_mm
.param_str = "V256bV256b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_nndm_MMM
.param_str = "V512bV512bV512b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_nndm_mmm
.param_str = "V256bV256bV256b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_orm_MMM
.param_str = "V512bV512bV512b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_orm_mmm
.param_str = "V256bV256bV256b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pack_f32a
.param_str = "ULifC*"
.target_set = TargetSet.initOne(.ve)
__builtin_ve_vl_pack_f32p
.param_str = "ULifC*fC*"
.target_set = TargetSet.initOne(.ve)
__builtin_ve_vl_pcvm_sml
.param_str = "LUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pfchv_ssl
.param_str = "vLivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pfchvnc_ssl
.param_str = "vLivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvadds_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvadds_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvadds_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvadds_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvadds_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvadds_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvaddu_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvaddu_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvaddu_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvaddu_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvaddu_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvaddu_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvand_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvand_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvand_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvand_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvand_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvand_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrd_vsMvl
.param_str = "V256dLUiV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrd_vsl
.param_str = "V256dLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrd_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrv_vvMvl
.param_str = "V256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrv_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrv_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrvlo_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrvlo_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrvlo_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrvup_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrvup_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvbrvup_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmps_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmps_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmps_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmps_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmps_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmps_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmpu_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmpu_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmpu_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmpu_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmpu_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcmpu_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcvtsw_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcvtsw_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcvtws_vvMvl
.param_str = "V256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcvtws_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcvtws_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcvtwsrz_vvMvl
.param_str = "V256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcvtwsrz_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvcvtwsrz_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pveqv_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pveqv_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pveqv_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pveqv_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pveqv_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pveqv_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfadd_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfadd_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfadd_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfadd_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfadd_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfadd_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfcmp_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfcmp_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfcmp_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfcmp_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfcmp_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfcmp_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmad_vsvvMvl
.param_str = "V256dLUiV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmad_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmad_vsvvvl
.param_str = "V256dLUiV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmad_vvsvMvl
.param_str = "V256dV256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmad_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmad_vvsvvl
.param_str = "V256dV256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmad_vvvvMvl
.param_str = "V256dV256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmad_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmad_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmax_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmax_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmax_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmax_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmax_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmax_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmin_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmin_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmin_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmin_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmin_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmin_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkaf_Ml
.param_str = "V512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkat_Ml
.param_str = "V512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkseq_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkseq_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkseqnan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkseqnan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksge_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksge_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksgenan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksgenan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksgt_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksgt_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksgtnan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksgtnan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksle_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksle_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslenan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslenan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksloeq_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksloeq_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksloeqnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksloeqnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksloge_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksloge_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslogenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslogenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslogt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslogt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslogtnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslogtnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslole_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslole_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslolenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslolenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslolt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslolt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksloltnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksloltnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslonan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslonan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslone_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslone_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslonenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslonenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslonum_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslonum_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslt_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkslt_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksltnan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksltnan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksnan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksnan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksne_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksne_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksnenan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksnenan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksnum_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksnum_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupeq_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupeq_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupeqnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupeqnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupge_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupge_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupgenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupgenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupgt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupgt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupgtnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupgtnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksuple_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksuple_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksuplenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksuplenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksuplt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksuplt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupltnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupltnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupne_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupne_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupnenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupnenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupnum_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmksupnum_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkweq_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkweq_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkweqnan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkweqnan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwge_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwge_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwgenan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwgenan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwgt_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwgt_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwgtnan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwgtnan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwle_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwle_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlenan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlenan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwloeq_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwloeq_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwloeqnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwloeqnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwloge_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwloge_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlogenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlogenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlogt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlogt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlogtnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlogtnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlole_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlole_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlolenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlolenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlolt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlolt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwloltnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwloltnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlonan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlonan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlone_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlone_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlonenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlonenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlonum_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlonum_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlt_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwlt_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwltnan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwltnan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwnan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwnan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwne_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwne_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwnenan_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwnenan_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwnum_MvMl
.param_str = "V512bV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwnum_Mvl
.param_str = "V512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupeq_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupeq_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupeqnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupeqnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupge_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupge_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupgenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupgenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupgt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupgt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupgtnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupgtnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwuple_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwuple_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwuplenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwuplenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwuplt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwuplt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupltnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupltnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupne_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupne_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupnenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupnenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupnum_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmkwupnum_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmsb_vsvvMvl
.param_str = "V256dLUiV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmsb_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmsb_vsvvvl
.param_str = "V256dLUiV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmsb_vvsvMvl
.param_str = "V256dV256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmsb_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmsb_vvsvvl
.param_str = "V256dV256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmsb_vvvvMvl
.param_str = "V256dV256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmsb_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmsb_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmul_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmul_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmul_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmul_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmul_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfmul_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmad_vsvvMvl
.param_str = "V256dLUiV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmad_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmad_vsvvvl
.param_str = "V256dLUiV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmad_vvsvMvl
.param_str = "V256dV256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmad_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmad_vvsvvl
.param_str = "V256dV256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmad_vvvvMvl
.param_str = "V256dV256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmad_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmad_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmsb_vsvvMvl
.param_str = "V256dLUiV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmsb_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmsb_vsvvvl
.param_str = "V256dLUiV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmsb_vvsvMvl
.param_str = "V256dV256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmsb_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmsb_vvsvvl
.param_str = "V256dV256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmsb_vvvvMvl
.param_str = "V256dV256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmsb_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfnmsb_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfsub_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfsub_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfsub_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfsub_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfsub_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvfsub_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvldz_vvMvl
.param_str = "V256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvldz_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvldz_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvldzlo_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvldzlo_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvldzlo_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvldzup_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvldzup_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvldzup_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmaxs_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmaxs_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmaxs_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmaxs_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmaxs_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmaxs_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmins_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmins_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmins_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmins_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmins_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvmins_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvor_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvor_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvor_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvor_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvor_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvor_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvpcnt_vvMvl
.param_str = "V256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvpcnt_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvpcnt_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvpcntlo_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvpcntlo_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvpcntlo_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvpcntup_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvpcntup_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvpcntup_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvrcp_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvrcp_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvrsqrt_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvrsqrt_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvrsqrtnex_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvrsqrtnex_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvseq_vl
.param_str = "V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvseq_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvseqlo_vl
.param_str = "V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvseqlo_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsequp_vl
.param_str = "V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsequp_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsla_vvsMvl
.param_str = "V256dV256dLUiV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsla_vvsl
.param_str = "V256dV256dLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsla_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsla_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsla_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsla_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsll_vvsMvl
.param_str = "V256dV256dLUiV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsll_vvsl
.param_str = "V256dV256dLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsll_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsll_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsll_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsll_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsra_vvsMvl
.param_str = "V256dV256dLUiV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsra_vvsl
.param_str = "V256dV256dLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsra_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsra_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsra_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsra_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsrl_vvsMvl
.param_str = "V256dV256dLUiV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsrl_vvsl
.param_str = "V256dV256dLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsrl_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsrl_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsrl_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsrl_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubs_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubs_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubs_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubs_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubs_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubs_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubu_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubu_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubu_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubu_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubu_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvsubu_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvxor_vsvMvl
.param_str = "V256dLUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvxor_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvxor_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvxor_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvxor_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_pvxor_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_scr_sss
.param_str = "vLUiLUiLUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_svm_sMs
.param_str = "LUiV512bLUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_svm_sms
.param_str = "LUiV256bLUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_svob
.param_str = "v"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_tovm_sml
.param_str = "LUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_tscr_ssss
.param_str = "LUiLUiLUiLUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddsl_vsvl
.param_str = "V256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddsl_vsvmvl
.param_str = "V256dLiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddsl_vsvvl
.param_str = "V256dLiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddsl_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddsl_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddsl_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswsx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswsx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswsx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswsx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswsx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswzx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswzx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswzx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswzx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddswzx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddul_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddul_vsvmvl
.param_str = "V256dLUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddul_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddul_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddul_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vaddul_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vadduw_vsvl
.param_str = "V256dUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vadduw_vsvmvl
.param_str = "V256dUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vadduw_vsvvl
.param_str = "V256dUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vadduw_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vadduw_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vadduw_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vand_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vand_vsvmvl
.param_str = "V256dLUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vand_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vand_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vand_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vand_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrdd_vsl
.param_str = "V256ddUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrdd_vsmvl
.param_str = "V256ddV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrdd_vsvl
.param_str = "V256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrdl_vsl
.param_str = "V256dLiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrdl_vsmvl
.param_str = "V256dLiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrdl_vsvl
.param_str = "V256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrds_vsl
.param_str = "V256dfUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrds_vsmvl
.param_str = "V256dfV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrds_vsvl
.param_str = "V256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrdw_vsl
.param_str = "V256diUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrdw_vsmvl
.param_str = "V256diV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrdw_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrv_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrv_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vbrv_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpsl_vsvl
.param_str = "V256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpsl_vsvmvl
.param_str = "V256dLiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpsl_vsvvl
.param_str = "V256dLiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpsl_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpsl_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpsl_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswsx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswsx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswsx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswsx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswsx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswzx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswzx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswzx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswzx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpswzx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpul_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpul_vsvmvl
.param_str = "V256dLUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpul_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpul_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpul_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpul_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpuw_vsvl
.param_str = "V256dUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpuw_vsvmvl
.param_str = "V256dUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpuw_vsvvl
.param_str = "V256dUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpuw_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpuw_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcmpuw_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcp_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtdl_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtdl_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtds_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtds_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtdw_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtdw_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtld_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtld_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtld_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtldrz_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtldrz_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtldrz_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtsd_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtsd_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtsw_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtsw_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdsx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdsx_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdsxrz_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdsxrz_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdsxrz_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdzx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdzx_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdzxrz_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdzxrz_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwdzxrz_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwssx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwssx_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwssx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwssxrz_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwssxrz_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwssxrz_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwszx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwszx_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwszx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwszxrz_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwszxrz_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vcvtwszxrz_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivsl_vsvl
.param_str = "V256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivsl_vsvmvl
.param_str = "V256dLiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivsl_vsvvl
.param_str = "V256dLiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivsl_vvsl
.param_str = "V256dV256dLiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivsl_vvsmvl
.param_str = "V256dV256dLiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivsl_vvsvl
.param_str = "V256dV256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivsl_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivsl_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivsl_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswsx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswsx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswsx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswsx_vvsl
.param_str = "V256dV256diUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswsx_vvsmvl
.param_str = "V256dV256diV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswsx_vvsvl
.param_str = "V256dV256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswsx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswsx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswzx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswzx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswzx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswzx_vvsl
.param_str = "V256dV256diUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswzx_vvsmvl
.param_str = "V256dV256diV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswzx_vvsvl
.param_str = "V256dV256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswzx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivswzx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivul_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivul_vsvmvl
.param_str = "V256dLUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivul_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivul_vvsl
.param_str = "V256dV256dLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivul_vvsmvl
.param_str = "V256dV256dLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivul_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivul_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivul_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivul_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivuw_vsvl
.param_str = "V256dUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivuw_vsvmvl
.param_str = "V256dUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivuw_vsvvl
.param_str = "V256dUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivuw_vvsl
.param_str = "V256dV256dUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivuw_vvsmvl
.param_str = "V256dV256dUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivuw_vvsvl
.param_str = "V256dV256dUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivuw_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivuw_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vdivuw_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_veqv_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_veqv_vsvmvl
.param_str = "V256dLUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_veqv_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_veqv_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_veqv_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_veqv_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vex_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfaddd_vsvl
.param_str = "V256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfaddd_vsvmvl
.param_str = "V256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfaddd_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfaddd_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfaddd_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfaddd_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfadds_vsvl
.param_str = "V256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfadds_vsvmvl
.param_str = "V256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfadds_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfadds_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfadds_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfadds_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmpd_vsvl
.param_str = "V256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmpd_vsvmvl
.param_str = "V256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmpd_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmpd_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmpd_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmpd_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmps_vsvl
.param_str = "V256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmps_vsvmvl
.param_str = "V256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmps_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmps_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmps_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfcmps_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivd_vsvl
.param_str = "V256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivd_vsvmvl
.param_str = "V256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivd_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivd_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivd_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivd_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivs_vsvl
.param_str = "V256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivs_vsvmvl
.param_str = "V256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivs_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivs_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivs_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfdivs_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmadd_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmadd_vsvvmvl
.param_str = "V256ddV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmadd_vsvvvl
.param_str = "V256ddV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmadd_vvsvl
.param_str = "V256dV256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmadd_vvsvmvl
.param_str = "V256dV256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmadd_vvsvvl
.param_str = "V256dV256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmadd_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmadd_vvvvmvl
.param_str = "V256dV256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmadd_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmads_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmads_vsvvmvl
.param_str = "V256dfV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmads_vsvvvl
.param_str = "V256dfV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmads_vvsvl
.param_str = "V256dV256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmads_vvsvmvl
.param_str = "V256dV256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmads_vvsvvl
.param_str = "V256dV256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmads_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmads_vvvvmvl
.param_str = "V256dV256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmads_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxd_vsvl
.param_str = "V256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxd_vsvmvl
.param_str = "V256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxd_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxd_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxd_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxd_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxs_vsvl
.param_str = "V256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxs_vsvmvl
.param_str = "V256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxs_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxs_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxs_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmaxs_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmind_vsvl
.param_str = "V256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmind_vsvmvl
.param_str = "V256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmind_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmind_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmind_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmind_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmins_vsvl
.param_str = "V256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmins_vsvmvl
.param_str = "V256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmins_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmins_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmins_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmins_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdeq_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdeq_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdeqnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdeqnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdge_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdge_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdgenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdgenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdgt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdgt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdgtnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdgtnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdle_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdle_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdlenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdlenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdlt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdlt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdltnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdltnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdne_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdne_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdnenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdnenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdnum_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkdnum_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklaf_ml
.param_str = "V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklat_ml
.param_str = "V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkleq_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkleq_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkleqnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkleqnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklge_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklge_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklgenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklgenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklgt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklgt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklgtnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklgtnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklle_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklle_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkllenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkllenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkllt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkllt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklltnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklltnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklne_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklne_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklnenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklnenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklnum_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmklnum_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkseq_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkseq_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkseqnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkseqnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksge_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksge_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksgenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksgenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksgt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksgt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksgtnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksgtnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksle_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksle_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkslenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkslenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkslt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkslt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksltnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksltnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksne_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksne_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksnenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksnenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksnum_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmksnum_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkweq_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkweq_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkweqnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkweqnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwge_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwge_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwgenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwgenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwgt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwgt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwgtnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwgtnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwle_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwle_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwlenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwlenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwlt_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwlt_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwltnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwltnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwnan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwnan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwne_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwne_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwnenan_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwnenan_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwnum_mvl
.param_str = "V256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmkwnum_mvml
.param_str = "V256bV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbd_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbd_vsvvmvl
.param_str = "V256ddV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbd_vsvvvl
.param_str = "V256ddV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbd_vvsvl
.param_str = "V256dV256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbd_vvsvmvl
.param_str = "V256dV256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbd_vvsvvl
.param_str = "V256dV256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbd_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbd_vvvvmvl
.param_str = "V256dV256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbd_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbs_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbs_vsvvmvl
.param_str = "V256dfV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbs_vsvvvl
.param_str = "V256dfV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbs_vvsvl
.param_str = "V256dV256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbs_vvsvmvl
.param_str = "V256dV256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbs_vvsvvl
.param_str = "V256dV256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbs_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbs_vvvvmvl
.param_str = "V256dV256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmsbs_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuld_vsvl
.param_str = "V256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuld_vsvmvl
.param_str = "V256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuld_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuld_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuld_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuld_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuls_vsvl
.param_str = "V256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuls_vsvmvl
.param_str = "V256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuls_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuls_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuls_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfmuls_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmadd_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmadd_vsvvmvl
.param_str = "V256ddV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmadd_vsvvvl
.param_str = "V256ddV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmadd_vvsvl
.param_str = "V256dV256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmadd_vvsvmvl
.param_str = "V256dV256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmadd_vvsvvl
.param_str = "V256dV256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmadd_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmadd_vvvvmvl
.param_str = "V256dV256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmadd_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmads_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmads_vsvvmvl
.param_str = "V256dfV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmads_vsvvvl
.param_str = "V256dfV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmads_vvsvl
.param_str = "V256dV256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmads_vvsvmvl
.param_str = "V256dV256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmads_vvsvvl
.param_str = "V256dV256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmads_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmads_vvvvmvl
.param_str = "V256dV256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmads_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbd_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbd_vsvvmvl
.param_str = "V256ddV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbd_vsvvvl
.param_str = "V256ddV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbd_vvsvl
.param_str = "V256dV256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbd_vvsvmvl
.param_str = "V256dV256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbd_vvsvvl
.param_str = "V256dV256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbd_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbd_vvvvmvl
.param_str = "V256dV256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbd_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbs_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbs_vsvvmvl
.param_str = "V256dfV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbs_vsvvvl
.param_str = "V256dfV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbs_vvsvl
.param_str = "V256dV256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbs_vvsvmvl
.param_str = "V256dV256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbs_vvsvvl
.param_str = "V256dV256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbs_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbs_vvvvmvl
.param_str = "V256dV256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfnmsbs_vvvvvl
.param_str = "V256dV256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmaxdfst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmaxdfst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmaxdlst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmaxdlst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmaxsfst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmaxsfst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmaxslst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmaxslst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmindfst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmindfst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmindlst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrmindlst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrminsfst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrminsfst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrminslst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfrminslst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsqrtd_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsqrtd_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsqrts_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsqrts_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubd_vsvl
.param_str = "V256ddV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubd_vsvmvl
.param_str = "V256ddV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubd_vsvvl
.param_str = "V256ddV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubd_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubd_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubd_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubs_vsvl
.param_str = "V256dfV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubs_vsvmvl
.param_str = "V256dfV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubs_vsvvl
.param_str = "V256dfV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubs_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubs_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsubs_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsumd_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsumd_vvml
.param_str = "V256dV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsums_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vfsums_vvml
.param_str = "V256dV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgt_vvssl
.param_str = "V256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgt_vvssml
.param_str = "V256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgt_vvssmvl
.param_str = "V256dV256dLUiLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgt_vvssvl
.param_str = "V256dV256dLUiLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlsx_vvssl
.param_str = "V256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlsx_vvssml
.param_str = "V256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlsx_vvssmvl
.param_str = "V256dV256dLUiLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlsx_vvssvl
.param_str = "V256dV256dLUiLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlsxnc_vvssl
.param_str = "V256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlsxnc_vvssml
.param_str = "V256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlsxnc_vvssmvl
.param_str = "V256dV256dLUiLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlsxnc_vvssvl
.param_str = "V256dV256dLUiLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlzx_vvssl
.param_str = "V256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlzx_vvssml
.param_str = "V256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlzx_vvssmvl
.param_str = "V256dV256dLUiLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlzx_vvssvl
.param_str = "V256dV256dLUiLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlzxnc_vvssl
.param_str = "V256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlzxnc_vvssml
.param_str = "V256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlzxnc_vvssmvl
.param_str = "V256dV256dLUiLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtlzxnc_vvssvl
.param_str = "V256dV256dLUiLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtnc_vvssl
.param_str = "V256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtnc_vvssml
.param_str = "V256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtnc_vvssmvl
.param_str = "V256dV256dLUiLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtnc_vvssvl
.param_str = "V256dV256dLUiLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtu_vvssl
.param_str = "V256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtu_vvssml
.param_str = "V256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtu_vvssmvl
.param_str = "V256dV256dLUiLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtu_vvssvl
.param_str = "V256dV256dLUiLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtunc_vvssl
.param_str = "V256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtunc_vvssml
.param_str = "V256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtunc_vvssmvl
.param_str = "V256dV256dLUiLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vgtunc_vvssvl
.param_str = "V256dV256dLUiLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vld2d_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vld2d_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vld2dnc_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vld2dnc_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vld_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vld_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldl2dsx_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldl2dsx_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldl2dsxnc_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldl2dsxnc_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldl2dzx_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldl2dzx_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldl2dzxnc_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldl2dzxnc_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldlsx_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldlsx_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldlsxnc_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldlsxnc_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldlzx_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldlzx_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldlzxnc_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldlzxnc_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldnc_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldnc_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldu2d_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldu2d_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldu2dnc_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldu2dnc_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldu_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldu_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldunc_vssl
.param_str = "V256dLUivC*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldunc_vssvl
.param_str = "V256dLUivC*V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldz_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldz_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vldz_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxsl_vsvl
.param_str = "V256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxsl_vsvmvl
.param_str = "V256dLiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxsl_vsvvl
.param_str = "V256dLiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxsl_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxsl_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxsl_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswsx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswsx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswsx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswsx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswsx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswzx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswzx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswzx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswzx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmaxswzx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminsl_vsvl
.param_str = "V256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminsl_vsvmvl
.param_str = "V256dLiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminsl_vsvvl
.param_str = "V256dLiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminsl_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminsl_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminsl_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswsx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswsx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswsx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswsx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswsx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswzx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswzx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswzx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswzx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vminswzx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmrg_vsvml
.param_str = "V256dLUiV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmrg_vsvmvl
.param_str = "V256dLUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmrg_vvvml
.param_str = "V256dV256dV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmrg_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmrgw_vsvMl
.param_str = "V256dUiV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmrgw_vsvMvl
.param_str = "V256dUiV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmrgw_vvvMl
.param_str = "V256dV256dV256dV512bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmrgw_vvvMvl
.param_str = "V256dV256dV256dV512bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulsl_vsvl
.param_str = "V256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulsl_vsvmvl
.param_str = "V256dLiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulsl_vsvvl
.param_str = "V256dLiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulsl_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulsl_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulsl_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulslw_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulslw_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulslw_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulslw_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswsx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswsx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswsx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswsx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswsx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswzx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswzx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswzx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswzx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulswzx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulul_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulul_vsvmvl
.param_str = "V256dLUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulul_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulul_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulul_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmulul_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmuluw_vsvl
.param_str = "V256dUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmuluw_vsvmvl
.param_str = "V256dUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmuluw_vsvvl
.param_str = "V256dUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmuluw_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmuluw_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmuluw_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmv_vsvl
.param_str = "V256dUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmv_vsvmvl
.param_str = "V256dUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vmv_vsvvl
.param_str = "V256dUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vor_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vor_vsvmvl
.param_str = "V256dLUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vor_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vor_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vor_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vor_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vpcnt_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vpcnt_vvmvl
.param_str = "V256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vpcnt_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrand_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrand_vvml
.param_str = "V256dV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrcpd_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrcpd_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrcps_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrcps_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxslfst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxslfst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxsllst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxsllst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxswfstsx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxswfstsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxswfstzx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxswfstzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxswlstsx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxswlstsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxswlstzx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrmaxswlstzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminslfst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminslfst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminsllst_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminsllst_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminswfstsx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminswfstsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminswfstzx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminswfstzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminswlstsx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminswlstsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminswlstzx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrminswlstzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vror_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vror_vvml
.param_str = "V256dV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrsqrtd_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrsqrtd_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrsqrtdnex_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrsqrtdnex_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrsqrts_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrsqrts_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrsqrtsnex_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrsqrtsnex_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrxor_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vrxor_vvml
.param_str = "V256dV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsc_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsc_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscl_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscl_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsclnc_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsclnc_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsclncot_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsclncot_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsclot_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsclot_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscnc_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscnc_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscncot_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscncot_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscot_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscot_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscu_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscu_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscunc_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscunc_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscuncot_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscuncot_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscuot_vvssl
.param_str = "vV256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vscuot_vvssml
.param_str = "vV256dV256dLUiLUiV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vseq_vl
.param_str = "V256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vseq_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsfa_vvssl
.param_str = "V256dV256dLUiLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsfa_vvssmvl
.param_str = "V256dV256dLUiLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsfa_vvssvl
.param_str = "V256dV256dLUiLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vshf_vvvsl
.param_str = "V256dV256dV256dLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vshf_vvvsvl
.param_str = "V256dV256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslal_vvsl
.param_str = "V256dV256dLiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslal_vvsmvl
.param_str = "V256dV256dLiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslal_vvsvl
.param_str = "V256dV256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslal_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslal_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslal_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawsx_vvsl
.param_str = "V256dV256diUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawsx_vvsmvl
.param_str = "V256dV256diV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawsx_vvsvl
.param_str = "V256dV256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawsx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawsx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawzx_vvsl
.param_str = "V256dV256diUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawzx_vvsmvl
.param_str = "V256dV256diV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawzx_vvsvl
.param_str = "V256dV256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawzx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vslawzx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsll_vvsl
.param_str = "V256dV256dLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsll_vvsmvl
.param_str = "V256dV256dLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsll_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsll_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsll_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsll_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsral_vvsl
.param_str = "V256dV256dLiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsral_vvsmvl
.param_str = "V256dV256dLiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsral_vvsvl
.param_str = "V256dV256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsral_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsral_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsral_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawsx_vvsl
.param_str = "V256dV256diUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawsx_vvsmvl
.param_str = "V256dV256diV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawsx_vvsvl
.param_str = "V256dV256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawsx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawsx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawzx_vvsl
.param_str = "V256dV256diUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawzx_vvsmvl
.param_str = "V256dV256diV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawzx_vvsvl
.param_str = "V256dV256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawzx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrawzx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrl_vvsl
.param_str = "V256dV256dLUiUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrl_vvsmvl
.param_str = "V256dV256dLUiV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrl_vvsvl
.param_str = "V256dV256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrl_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrl_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsrl_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vst2d_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vst2d_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vst2dnc_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vst2dnc_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vst2dncot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vst2dncot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vst2dot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vst2dot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vst_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vst_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstl2d_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstl2d_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstl2dnc_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstl2dnc_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstl2dncot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstl2dncot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstl2dot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstl2dot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstl_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstl_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstlnc_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstlnc_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstlncot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstlncot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstlot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstlot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstnc_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstnc_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstncot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstncot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstu2d_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstu2d_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstu2dnc_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstu2dnc_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstu2dncot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstu2dncot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstu2dot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstu2dot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstu_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstu_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstunc_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstunc_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstuncot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstuncot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstuot_vssl
.param_str = "vV256dLUiv*Ui"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vstuot_vssml
.param_str = "vV256dLUiv*V256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubsl_vsvl
.param_str = "V256dLiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubsl_vsvmvl
.param_str = "V256dLiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubsl_vsvvl
.param_str = "V256dLiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubsl_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubsl_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubsl_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswsx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswsx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswsx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswsx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswsx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswsx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswzx_vsvl
.param_str = "V256diV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswzx_vsvmvl
.param_str = "V256diV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswzx_vsvvl
.param_str = "V256diV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswzx_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswzx_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubswzx_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubul_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubul_vsvmvl
.param_str = "V256dLUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubul_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubul_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubul_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubul_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubuw_vsvl
.param_str = "V256dUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubuw_vsvmvl
.param_str = "V256dUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubuw_vsvvl
.param_str = "V256dUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubuw_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubuw_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsubuw_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsuml_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsuml_vvml
.param_str = "V256dV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsumwsx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsumwsx_vvml
.param_str = "V256dV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsumwzx_vvl
.param_str = "V256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vsumwzx_vvml
.param_str = "V256dV256dV256bUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vxor_vsvl
.param_str = "V256dLUiV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vxor_vsvmvl
.param_str = "V256dLUiV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vxor_vsvvl
.param_str = "V256dLUiV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vxor_vvvl
.param_str = "V256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vxor_vvvmvl
.param_str = "V256dV256dV256dV256bV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_vxor_vvvvl
.param_str = "V256dV256dV256dV256dUi"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_xorm_MMM
.param_str = "V512bV512bV512b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_ve_vl_xorm_mmm
.param_str = "V256bV256bV256b"
.target_set = TargetSet.initOne(.vevl_gen)
__builtin_vfprintf
.param_str = "iP*RcC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vprintf, .format_string_position = 1 }
__builtin_vfscanf
.param_str = "iP*RcC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vscanf, .format_string_position = 1 }
__builtin_vprintf
.param_str = "icC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vprintf }
__builtin_vscanf
.param_str = "icC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vscanf }
__builtin_vsnprintf
.param_str = "ic*RzcC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vprintf, .format_string_position = 2 }
__builtin_vsprintf
.param_str = "ic*RcC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vprintf, .format_string_position = 1 }
__builtin_vsscanf
.param_str = "icC*RcC*Ra"
.attributes = .{ .lib_function_with_builtin_prefix = true, .format_kind = .vscanf, .format_string_position = 1 }
__builtin_wasm_max_f32
.param_str = "fff"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_max_f64
.param_str = "ddd"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_memory_grow
.param_str = "zIiz"
.target_set = TargetSet.initOne(.webassembly)
__builtin_wasm_memory_size
.param_str = "zIi"
.target_set = TargetSet.initOne(.webassembly)
__builtin_wasm_min_f32
.param_str = "fff"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_min_f64
.param_str = "ddd"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_trunc_s_i32_f32
.param_str = "if"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_trunc_s_i32_f64
.param_str = "id"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_trunc_s_i64_f32
.param_str = "LLif"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_trunc_s_i64_f64
.param_str = "LLid"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_trunc_u_i32_f32
.param_str = "if"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_trunc_u_i32_f64
.param_str = "id"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_trunc_u_i64_f32
.param_str = "LLif"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wasm_trunc_u_i64_f64
.param_str = "LLid"
.target_set = TargetSet.initOne(.webassembly)
.attributes = .{ .@"const" = true }
__builtin_wcschr
.param_str = "w*wC*w"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_wcscmp
.param_str = "iwC*wC*"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_wcslen
.param_str = "zwC*"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_wcsncmp
.param_str = "iwC*wC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_wmemchr
.param_str = "w*wC*wz"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_wmemcmp
.param_str = "iwC*wC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_wmemcpy
.param_str = "w*w*wC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__builtin_wmemmove
.param_str = "w*w*wC*z"
.attributes = .{ .lib_function_with_builtin_prefix = true, .const_evaluable = true }
__c11_atomic_is_lock_free
.param_str = "bz"
.attributes = .{ .const_evaluable = true }
__c11_atomic_signal_fence
.param_str = "vi"
__c11_atomic_thread_fence
.param_str = "vi"
__clear_cache
.param_str = "vv*v*"
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__cospi
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
__cospif
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
__debugbreak
.param_str = "v"
.language = .all_ms_languages
__dmb
.param_str = "vUi"
.language = .all_ms_languages
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__dsb
.param_str = "vUi"
.language = .all_ms_languages
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__emit
.param_str = "vIUiC"
.language = .all_ms_languages
.target_set = TargetSet.initOne(.arm)
__exception_code
.param_str = "UNi"
.language = .all_ms_languages
__exception_info
.param_str = "v*"
.language = .all_ms_languages
__exp10
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
__exp10f
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
__fastfail
.param_str = "vUi"
.language = .all_ms_languages
.attributes = .{ .noreturn = true }
__finite
.param_str = "id"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
__finitef
.param_str = "if"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
__finitel
.param_str = "iLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
__isb
.param_str = "vUi"
.language = .all_ms_languages
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
.attributes = .{ .@"const" = true }
__iso_volatile_load16
.param_str = "ssCD*"
.language = .all_ms_languages
__iso_volatile_load32
.param_str = "iiCD*"
.language = .all_ms_languages
__iso_volatile_load64
.param_str = "LLiLLiCD*"
.language = .all_ms_languages
__iso_volatile_load8
.param_str = "ccCD*"
.language = .all_ms_languages
__iso_volatile_store16
.param_str = "vsD*s"
.language = .all_ms_languages
__iso_volatile_store32
.param_str = "viD*i"
.language = .all_ms_languages
__iso_volatile_store64
.param_str = "vLLiD*LLi"
.language = .all_ms_languages
__iso_volatile_store8
.param_str = "vcD*c"
.language = .all_ms_languages
__ldrexd
.param_str = "WiWiCD*"
.language = .all_ms_languages
.target_set = TargetSet.initOne(.arm)
__lzcnt
.param_str = "UiUi"
.language = .all_ms_languages
.attributes = .{ .@"const" = true, .const_evaluable = true }
__lzcnt16
.param_str = "UsUs"
.language = .all_ms_languages
.attributes = .{ .@"const" = true, .const_evaluable = true }
__lzcnt64
.param_str = "UWiUWi"
.language = .all_ms_languages
.attributes = .{ .@"const" = true, .const_evaluable = true }
__noop
.param_str = "i."
.language = .all_ms_languages
__nvvm_add_rm_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rm_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rm_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rn_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rn_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rn_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rp_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rp_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rp_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rz_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_add_rz_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_add_gen_f
.param_str = "ffD*f"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_add_gen_i
.param_str = "iiD*i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_add_gen_l
.param_str = "LiLiD*Li"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_add_gen_ll
.param_str = "LLiLLiD*LLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_and_gen_i
.param_str = "iiD*i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_and_gen_l
.param_str = "LiLiD*Li"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_and_gen_ll
.param_str = "LLiLLiD*LLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_cas_gen_i
.param_str = "iiD*ii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_cas_gen_l
.param_str = "LiLiD*LiLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_cas_gen_ll
.param_str = "LLiLLiD*LLiLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_dec_gen_ui
.param_str = "UiUiD*Ui"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_inc_gen_ui
.param_str = "UiUiD*Ui"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_max_gen_i
.param_str = "iiD*i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_max_gen_l
.param_str = "LiLiD*Li"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_max_gen_ll
.param_str = "LLiLLiD*LLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_max_gen_ui
.param_str = "UiUiD*Ui"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_max_gen_ul
.param_str = "ULiULiD*ULi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_max_gen_ull
.param_str = "ULLiULLiD*ULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_min_gen_i
.param_str = "iiD*i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_min_gen_l
.param_str = "LiLiD*Li"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_min_gen_ll
.param_str = "LLiLLiD*LLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_min_gen_ui
.param_str = "UiUiD*Ui"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_min_gen_ul
.param_str = "ULiULiD*ULi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_min_gen_ull
.param_str = "ULLiULLiD*ULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_or_gen_i
.param_str = "iiD*i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_or_gen_l
.param_str = "LiLiD*Li"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_or_gen_ll
.param_str = "LLiLLiD*LLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_sub_gen_i
.param_str = "iiD*i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_sub_gen_l
.param_str = "LiLiD*Li"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_sub_gen_ll
.param_str = "LLiLLiD*LLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_xchg_gen_i
.param_str = "iiD*i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_xchg_gen_l
.param_str = "LiLiD*Li"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_xchg_gen_ll
.param_str = "LLiLLiD*LLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_xor_gen_i
.param_str = "iiD*i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_xor_gen_l
.param_str = "LiLiD*Li"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_atom_xor_gen_ll
.param_str = "LLiLLiD*LLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_bar0_and
.param_str = "ii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_bar0_or
.param_str = "ii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_bar0_popc
.param_str = "ii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_bar_sync
.param_str = "vi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_bitcast_d2ll
.param_str = "LLid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_bitcast_f2i
.param_str = "if"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_bitcast_i2f
.param_str = "fi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_bitcast_ll2d
.param_str = "dLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ceil_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ceil_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ceil_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_compiler_error
.param_str = "vcC*4"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_compiler_warn
.param_str = "vcC*4"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_cos_approx_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_cos_approx_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2f_rm
.param_str = "fd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2f_rm_ftz
.param_str = "fd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2f_rn
.param_str = "fd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2f_rn_ftz
.param_str = "fd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2f_rp
.param_str = "fd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2f_rp_ftz
.param_str = "fd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2f_rz
.param_str = "fd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2f_rz_ftz
.param_str = "fd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2i_hi
.param_str = "id"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2i_lo
.param_str = "id"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2i_rm
.param_str = "id"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2i_rn
.param_str = "id"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2i_rp
.param_str = "id"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2i_rz
.param_str = "id"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ll_rm
.param_str = "LLid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ll_rn
.param_str = "LLid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ll_rp
.param_str = "LLid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ll_rz
.param_str = "LLid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ui_rm
.param_str = "Uid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ui_rn
.param_str = "Uid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ui_rp
.param_str = "Uid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ui_rz
.param_str = "Uid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ull_rm
.param_str = "ULLid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ull_rn
.param_str = "ULLid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ull_rp
.param_str = "ULLid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_d2ull_rz
.param_str = "ULLid"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_approx_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_approx_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rm_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rm_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rm_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rn_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rn_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rn_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rp_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rp_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rp_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rz_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_div_rz_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ex2_approx_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ex2_approx_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ex2_approx_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2h_rn
.param_str = "Usf"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2h_rn_ftz
.param_str = "Usf"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2i_rm
.param_str = "if"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2i_rm_ftz
.param_str = "if"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2i_rn
.param_str = "if"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2i_rn_ftz
.param_str = "if"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2i_rp
.param_str = "if"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2i_rp_ftz
.param_str = "if"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2i_rz
.param_str = "if"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2i_rz_ftz
.param_str = "if"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ll_rm
.param_str = "LLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ll_rm_ftz
.param_str = "LLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ll_rn
.param_str = "LLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ll_rn_ftz
.param_str = "LLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ll_rp
.param_str = "LLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ll_rp_ftz
.param_str = "LLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ll_rz
.param_str = "LLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ll_rz_ftz
.param_str = "LLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ui_rm
.param_str = "Uif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ui_rm_ftz
.param_str = "Uif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ui_rn
.param_str = "Uif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ui_rn_ftz
.param_str = "Uif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ui_rp
.param_str = "Uif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ui_rp_ftz
.param_str = "Uif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ui_rz
.param_str = "Uif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ui_rz_ftz
.param_str = "Uif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ull_rm
.param_str = "ULLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ull_rm_ftz
.param_str = "ULLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ull_rn
.param_str = "ULLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ull_rn_ftz
.param_str = "ULLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ull_rp
.param_str = "ULLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ull_rp_ftz
.param_str = "ULLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ull_rz
.param_str = "ULLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_f2ull_rz_ftz
.param_str = "ULLif"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fabs_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fabs_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fabs_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_floor_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_floor_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_floor_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rm_d
.param_str = "dddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rm_f
.param_str = "ffff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rm_ftz_f
.param_str = "ffff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rn_d
.param_str = "dddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rn_f
.param_str = "ffff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rn_ftz_f
.param_str = "ffff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rp_d
.param_str = "dddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rp_f
.param_str = "ffff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rp_ftz_f
.param_str = "ffff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rz_d
.param_str = "dddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rz_f
.param_str = "ffff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fma_rz_ftz_f
.param_str = "ffff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fmax_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fmax_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fmax_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fmin_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fmin_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_fmin_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_i2d_rm
.param_str = "di"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_i2d_rn
.param_str = "di"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_i2d_rp
.param_str = "di"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_i2d_rz
.param_str = "di"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_i2f_rm
.param_str = "fi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_i2f_rn
.param_str = "fi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_i2f_rp
.param_str = "fi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_i2f_rz
.param_str = "fi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_isspacep_const
.param_str = "bvC*"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_isspacep_global
.param_str = "bvC*"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_isspacep_local
.param_str = "bvC*"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_isspacep_shared
.param_str = "bvC*"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_ldg_c
.param_str = "ccC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_c2
.param_str = "E2cE2cC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_c4
.param_str = "E4cE4cC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_d
.param_str = "ddC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_d2
.param_str = "E2dE2dC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_f
.param_str = "ffC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_f2
.param_str = "E2fE2fC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_f4
.param_str = "E4fE4fC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_h
.param_str = "hhC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_h2
.param_str = "E2hE2hC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_i
.param_str = "iiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_i2
.param_str = "E2iE2iC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_i4
.param_str = "E4iE4iC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_l
.param_str = "LiLiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_l2
.param_str = "E2LiE2LiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_ll
.param_str = "LLiLLiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_ll2
.param_str = "E2LLiE2LLiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_s
.param_str = "ssC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_s2
.param_str = "E2sE2sC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_s4
.param_str = "E4sE4sC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_sc
.param_str = "ScScC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_sc2
.param_str = "E2ScE2ScC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_sc4
.param_str = "E4ScE4ScC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_uc
.param_str = "UcUcC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_uc2
.param_str = "E2UcE2UcC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_uc4
.param_str = "E4UcE4UcC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_ui
.param_str = "UiUiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_ui2
.param_str = "E2UiE2UiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_ui4
.param_str = "E4UiE4UiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_ul
.param_str = "ULiULiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_ul2
.param_str = "E2ULiE2ULiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_ull
.param_str = "ULLiULLiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_ull2
.param_str = "E2ULLiE2ULLiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_us
.param_str = "UsUsC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_us2
.param_str = "E2UsE2UsC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldg_us4
.param_str = "E4UsE4UsC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_c
.param_str = "ccC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_c2
.param_str = "E2cE2cC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_c4
.param_str = "E4cE4cC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_d
.param_str = "ddC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_d2
.param_str = "E2dE2dC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_f
.param_str = "ffC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_f2
.param_str = "E2fE2fC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_f4
.param_str = "E4fE4fC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_h
.param_str = "hhC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_h2
.param_str = "E2hE2hC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_i
.param_str = "iiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_i2
.param_str = "E2iE2iC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_i4
.param_str = "E4iE4iC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_l
.param_str = "LiLiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_l2
.param_str = "E2LiE2LiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_ll
.param_str = "LLiLLiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_ll2
.param_str = "E2LLiE2LLiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_s
.param_str = "ssC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_s2
.param_str = "E2sE2sC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_s4
.param_str = "E4sE4sC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_sc
.param_str = "ScScC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_sc2
.param_str = "E2ScE2ScC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_sc4
.param_str = "E4ScE4ScC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_uc
.param_str = "UcUcC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_uc2
.param_str = "E2UcE2UcC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_uc4
.param_str = "E4UcE4UcC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_ui
.param_str = "UiUiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_ui2
.param_str = "E2UiE2UiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_ui4
.param_str = "E4UiE4UiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_ul
.param_str = "ULiULiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_ul2
.param_str = "E2ULiE2ULiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_ull
.param_str = "ULLiULLiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_ull2
.param_str = "E2ULLiE2ULLiC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_us
.param_str = "UsUsC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_us2
.param_str = "E2UsE2UsC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ldu_us4
.param_str = "E4UsE4UsC*"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_lg2_approx_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_lg2_approx_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_lg2_approx_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ll2d_rm
.param_str = "dLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ll2d_rn
.param_str = "dLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ll2d_rp
.param_str = "dLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ll2d_rz
.param_str = "dLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ll2f_rm
.param_str = "fLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ll2f_rn
.param_str = "fLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ll2f_rp
.param_str = "fLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ll2f_rz
.param_str = "fLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_lohi_i2d
.param_str = "dii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_membar_cta
.param_str = "v"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_membar_gl
.param_str = "v"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_membar_sys
.param_str = "v"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_memcpy
.param_str = "vUc*Uc*zi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_memset
.param_str = "vUc*Uczi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul24_i
.param_str = "iii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul24_ui
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rm_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rm_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rm_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rn_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rn_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rn_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rp_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rp_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rp_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rz_d
.param_str = "ddd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mul_rz_ftz_f
.param_str = "fff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mulhi_i
.param_str = "iii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mulhi_ll
.param_str = "LLiLLiLLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mulhi_ui
.param_str = "UiUiUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_mulhi_ull
.param_str = "ULLiULLiULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_prmt
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_approx_ftz_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_approx_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rm_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rm_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rm_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rn_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rn_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rn_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rp_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rp_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rp_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rz_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rcp_rz_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_read_ptx_sreg_clock
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_read_ptx_sreg_clock64
.param_str = "LLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_read_ptx_sreg_ctaid_w
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_ctaid_x
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_ctaid_y
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_ctaid_z
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_gridid
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_laneid
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_lanemask_eq
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_lanemask_ge
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_lanemask_gt
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_lanemask_le
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_lanemask_lt
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_nctaid_w
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_nctaid_x
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_nctaid_y
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_nctaid_z
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_nsmid
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_ntid_w
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_ntid_x
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_ntid_y
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_ntid_z
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_nwarpid
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_pm0
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_read_ptx_sreg_pm1
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_read_ptx_sreg_pm2
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_read_ptx_sreg_pm3
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_read_ptx_sreg_smid
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_tid_w
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_tid_x
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_tid_y
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_tid_z
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_read_ptx_sreg_warpid
.param_str = "i"
.target_set = TargetSet.initOne(.nvptx)
.attributes = .{ .@"const" = true }
__nvvm_round_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_round_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_round_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rsqrt_approx_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rsqrt_approx_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_rsqrt_approx_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sad_i
.param_str = "iiii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sad_ui
.param_str = "UiUiUiUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_saturate_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_saturate_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_saturate_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_shfl_bfly_f32
.param_str = "ffii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_shfl_bfly_i32
.param_str = "iiii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_shfl_down_f32
.param_str = "ffii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_shfl_down_i32
.param_str = "iiii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_shfl_idx_f32
.param_str = "ffii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_shfl_idx_i32
.param_str = "iiii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_shfl_up_f32
.param_str = "ffii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_shfl_up_i32
.param_str = "iiii"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sin_approx_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sin_approx_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_approx_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_approx_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rm_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rm_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rm_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rn_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rn_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rn_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rp_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rp_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rp_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rz_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_sqrt_rz_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_trunc_d
.param_str = "dd"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_trunc_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_trunc_ftz_f
.param_str = "ff"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ui2d_rm
.param_str = "dUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ui2d_rn
.param_str = "dUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ui2d_rp
.param_str = "dUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ui2d_rz
.param_str = "dUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ui2f_rm
.param_str = "fUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ui2f_rn
.param_str = "fUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ui2f_rp
.param_str = "fUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ui2f_rz
.param_str = "fUi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ull2d_rm
.param_str = "dULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ull2d_rn
.param_str = "dULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ull2d_rp
.param_str = "dULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ull2d_rz
.param_str = "dULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ull2f_rm
.param_str = "fULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ull2f_rn
.param_str = "fULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ull2f_rp
.param_str = "fULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_ull2f_rz
.param_str = "fULLi"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_vote_all
.param_str = "bb"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_vote_any
.param_str = "bb"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_vote_ballot
.param_str = "Uib"
.target_set = TargetSet.initOne(.nvptx)
__nvvm_vote_uni
.param_str = "bb"
.target_set = TargetSet.initOne(.nvptx)
__popcnt
.param_str = "UiUi"
.language = .all_ms_languages
.attributes = .{ .@"const" = true, .const_evaluable = true }
__popcnt16
.param_str = "UsUs"
.language = .all_ms_languages
.attributes = .{ .@"const" = true, .const_evaluable = true }
__popcnt64
.param_str = "UWiUWi"
.language = .all_ms_languages
.attributes = .{ .@"const" = true, .const_evaluable = true }
__rdtsc
.param_str = "UOi"
.target_set = TargetSet.initOne(.x86)
__sev
.param_str = "v"
.language = .all_ms_languages
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__sevl
.param_str = "v"
.language = .all_ms_languages
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__sigsetjmp
.param_str = "iSJi"
.header = .setjmp
.attributes = .{ .allow_type_mismatch = true, .lib_function_without_prefix = true, .returns_twice = true }
__sinpi
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
__sinpif
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
__sync_add_and_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_add_and_fetch_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_add_and_fetch_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_add_and_fetch_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_add_and_fetch_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_add_and_fetch_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_and_and_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_and_and_fetch_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_and_and_fetch_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_and_and_fetch_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_and_and_fetch_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_and_and_fetch_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_bool_compare_and_swap
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_bool_compare_and_swap_1
.param_str = "bcD*cc."
.attributes = .{ .custom_typecheck = true }
__sync_bool_compare_and_swap_16
.param_str = "bLLLiD*LLLiLLLi."
.attributes = .{ .custom_typecheck = true }
__sync_bool_compare_and_swap_2
.param_str = "bsD*ss."
.attributes = .{ .custom_typecheck = true }
__sync_bool_compare_and_swap_4
.param_str = "biD*ii."
.attributes = .{ .custom_typecheck = true }
__sync_bool_compare_and_swap_8
.param_str = "bLLiD*LLiLLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_add
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_add_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_add_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_add_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_add_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_add_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_and
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_and_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_and_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_and_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_and_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_and_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_max
.param_str = "iiD*i"
__sync_fetch_and_min
.param_str = "iiD*i"
__sync_fetch_and_nand
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_nand_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_nand_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_nand_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_nand_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_nand_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_or
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_or_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_or_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_or_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_or_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_or_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_sub
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_sub_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_sub_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_sub_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_sub_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_sub_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_umax
.param_str = "UiUiD*Ui"
__sync_fetch_and_umin
.param_str = "UiUiD*Ui"
__sync_fetch_and_xor
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_xor_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_xor_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_xor_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_xor_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_fetch_and_xor_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_lock_release
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_lock_release_1
.param_str = "vcD*."
.attributes = .{ .custom_typecheck = true }
__sync_lock_release_16
.param_str = "vLLLiD*."
.attributes = .{ .custom_typecheck = true }
__sync_lock_release_2
.param_str = "vsD*."
.attributes = .{ .custom_typecheck = true }
__sync_lock_release_4
.param_str = "viD*."
.attributes = .{ .custom_typecheck = true }
__sync_lock_release_8
.param_str = "vLLiD*."
.attributes = .{ .custom_typecheck = true }
__sync_lock_test_and_set
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_lock_test_and_set_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_lock_test_and_set_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_lock_test_and_set_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_lock_test_and_set_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_lock_test_and_set_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_nand_and_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_nand_and_fetch_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_nand_and_fetch_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_nand_and_fetch_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_nand_and_fetch_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_nand_and_fetch_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_or_and_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_or_and_fetch_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_or_and_fetch_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_or_and_fetch_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_or_and_fetch_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_or_and_fetch_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_sub_and_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_sub_and_fetch_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_sub_and_fetch_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_sub_and_fetch_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_sub_and_fetch_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_sub_and_fetch_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_swap
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_swap_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_swap_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_swap_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_swap_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_swap_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__sync_synchronize
.param_str = "v"
__sync_val_compare_and_swap
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_val_compare_and_swap_1
.param_str = "ccD*cc."
.attributes = .{ .custom_typecheck = true }
__sync_val_compare_and_swap_16
.param_str = "LLLiLLLiD*LLLiLLLi."
.attributes = .{ .custom_typecheck = true }
__sync_val_compare_and_swap_2
.param_str = "ssD*ss."
.attributes = .{ .custom_typecheck = true }
__sync_val_compare_and_swap_4
.param_str = "iiD*ii."
.attributes = .{ .custom_typecheck = true }
__sync_val_compare_and_swap_8
.param_str = "LLiLLiD*LLiLLi."
.attributes = .{ .custom_typecheck = true }
__sync_xor_and_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__sync_xor_and_fetch_1
.param_str = "ccD*c."
.attributes = .{ .custom_typecheck = true }
__sync_xor_and_fetch_16
.param_str = "LLLiLLLiD*LLLi."
.attributes = .{ .custom_typecheck = true }
__sync_xor_and_fetch_2
.param_str = "ssD*s."
.attributes = .{ .custom_typecheck = true }
__sync_xor_and_fetch_4
.param_str = "iiD*i."
.attributes = .{ .custom_typecheck = true }
__sync_xor_and_fetch_8
.param_str = "LLiLLiD*LLi."
.attributes = .{ .custom_typecheck = true }
__syncthreads
.param_str = "v"
.target_set = TargetSet.initOne(.nvptx)
__tanpi
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
__tanpif
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
__va_start
.param_str = "vc**."
.language = .all_ms_languages
.attributes = .{ .custom_typecheck = true }
__warn_memset_zero_len
.param_str = "v"
.attributes = .{ .pure = true }
__wfe
.param_str = "v"
.language = .all_ms_languages
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__wfi
.param_str = "v"
.language = .all_ms_languages
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
__xray_customevent
.param_str = "vcC*z"
__xray_typedevent
.param_str = "vzcC*z"
__yield
.param_str = "v"
.language = .all_ms_languages
.target_set = TargetSet.initMany(&.{ .aarch64, .arm })
_abnormal_termination
.param_str = "i"
.language = .all_ms_languages
_alloca
.param_str = "v*z"
.language = .all_ms_languages
_bittest
.param_str = "UcNiC*Ni"
.language = .all_ms_languages
_bittest64
.param_str = "UcWiC*Wi"
.language = .all_ms_languages
_bittestandcomplement
.param_str = "UcNi*Ni"
.language = .all_ms_languages
_bittestandcomplement64
.param_str = "UcWi*Wi"
.language = .all_ms_languages
_bittestandreset
.param_str = "UcNi*Ni"
.language = .all_ms_languages
_bittestandreset64
.param_str = "UcWi*Wi"
.language = .all_ms_languages
_bittestandset
.param_str = "UcNi*Ni"
.language = .all_ms_languages
_bittestandset64
.param_str = "UcWi*Wi"
.language = .all_ms_languages
_byteswap_uint64
.param_str = "ULLiULLi"
.header = .stdlib, .language = .all_ms_languages
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
_byteswap_ulong
.param_str = "UNiUNi"
.header = .stdlib, .language = .all_ms_languages
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
_byteswap_ushort
.param_str = "UsUs"
.header = .stdlib, .language = .all_ms_languages
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
_exception_code
.param_str = "UNi"
.language = .all_ms_languages
_exception_info
.param_str = "v*"
.language = .all_ms_languages
_exit
.param_str = "vi"
.header = .unistd, .language = .all_gnu_languages
.attributes = .{ .noreturn = true, .lib_function_without_prefix = true }
_interlockedbittestandreset
.param_str = "UcNiD*Ni"
.language = .all_ms_languages
_interlockedbittestandreset64
.param_str = "UcWiD*Wi"
.language = .all_ms_languages
_interlockedbittestandreset_acq
.param_str = "UcNiD*Ni"
.language = .all_ms_languages
_interlockedbittestandreset_nf
.param_str = "UcNiD*Ni"
.language = .all_ms_languages
_interlockedbittestandreset_rel
.param_str = "UcNiD*Ni"
.language = .all_ms_languages
_interlockedbittestandset
.param_str = "UcNiD*Ni"
.language = .all_ms_languages
_interlockedbittestandset64
.param_str = "UcWiD*Wi"
.language = .all_ms_languages
_interlockedbittestandset_acq
.param_str = "UcNiD*Ni"
.language = .all_ms_languages
_interlockedbittestandset_nf
.param_str = "UcNiD*Ni"
.language = .all_ms_languages
_interlockedbittestandset_rel
.param_str = "UcNiD*Ni"
.language = .all_ms_languages
_longjmp
.param_str = "vJi"
.header = .setjmp, .language = .all_gnu_languages
.attributes = .{ .noreturn = true, .allow_type_mismatch = true, .lib_function_without_prefix = true }
_lrotl
.param_str = "ULiULii"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
_lrotr
.param_str = "ULiULii"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
_rotl
.param_str = "UiUii"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
_rotl16
.param_str = "UsUsUc"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
_rotl64
.param_str = "UWiUWii"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
_rotl8
.param_str = "UcUcUc"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
_rotr
.param_str = "UiUii"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
_rotr16
.param_str = "UsUsUc"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
_rotr64
.param_str = "UWiUWii"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
_rotr8
.param_str = "UcUcUc"
.language = .all_ms_languages
.attributes = .{ .const_evaluable = true }
_setjmp
.param_str = "iJ"
.header = .setjmp
.attributes = .{ .allow_type_mismatch = true, .lib_function_without_prefix = true, .returns_twice = true }
_setjmpex
.param_str = "iJ"
.header = .setjmpex, .language = .all_ms_languages
.attributes = .{ .allow_type_mismatch = true, .lib_function_without_prefix = true, .returns_twice = true }
abort
.param_str = "v"
.header = .stdlib
.attributes = .{ .noreturn = true, .lib_function_without_prefix = true }
abs
.param_str = "ii"
.header = .stdlib
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
acos
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
acosf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
acosh
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
acoshf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
acoshl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
acosl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
aligned_alloc
.param_str = "v*zz"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
alloca
.param_str = "v*z"
.header = .stdlib, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
asin
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
asinf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
asinh
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
asinhf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
asinhl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
asinl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
atan
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
atan2
.param_str = "ddd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
atan2f
.param_str = "fff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
atan2l
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
atanf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
atanh
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
atanhf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
atanhl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
atanl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
bcmp
.param_str = "ivC*vC*z"
.header = .strings, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
bcopy
.param_str = "vvC*v*z"
.header = .strings, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
bzero
.param_str = "vv*z"
.header = .strings, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
cabs
.param_str = "dXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cabsf
.param_str = "fXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cabsl
.param_str = "LdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cacos
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cacosf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cacosh
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cacoshf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cacoshl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cacosl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
calloc
.param_str = "v*zz"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
carg
.param_str = "dXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cargf
.param_str = "fXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cargl
.param_str = "LdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
casin
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
casinf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
casinh
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
casinhf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
casinhl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
casinl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
catan
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
catanf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
catanh
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
catanhf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
catanhl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
catanl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cbrt
.param_str = "dd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
cbrtf
.param_str = "ff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
cbrtl
.param_str = "LdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
ccos
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ccosf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ccosh
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ccoshf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ccoshl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ccosl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ceil
.param_str = "dd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
ceilf
.param_str = "ff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
ceill
.param_str = "LdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
cexp
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cexpf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cexpl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cimag
.param_str = "dXd"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
cimagf
.param_str = "fXf"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
cimagl
.param_str = "LdXLd"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
clog
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
clogf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
clogl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
conj
.param_str = "XdXd"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
conjf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
conjl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
copysign
.param_str = "ddd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
copysignf
.param_str = "fff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
copysignl
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
cos
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cosf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cosh
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
coshf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
coshl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cosl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cpow
.param_str = "XdXdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cpowf
.param_str = "XfXfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cpowl
.param_str = "XLdXLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
cproj
.param_str = "XdXd"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
cprojf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
cprojl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
creal
.param_str = "dXd"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
crealf
.param_str = "fXf"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
creall
.param_str = "LdXLd"
.header = .complex
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
csin
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
csinf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
csinh
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
csinhf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
csinhl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
csinl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
csqrt
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
csqrtf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
csqrtl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ctan
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ctanf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ctanh
.param_str = "XdXd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ctanhf
.param_str = "XfXf"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ctanhl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ctanl
.param_str = "XLdXLd"
.header = .complex
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
erf
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
erfc
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
erfcf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
erfcl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
erff
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
erfl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
exit
.param_str = "vi"
.header = .stdlib
.attributes = .{ .noreturn = true, .lib_function_without_prefix = true }
exp
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
exp2
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
exp2f
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
exp2l
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
expf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
expl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
expm1
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
expm1f
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
expm1l
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
fabs
.param_str = "dd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
fabsf
.param_str = "ff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
fabsl
.param_str = "LdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
fdim
.param_str = "ddd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
fdimf
.param_str = "fff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
fdiml
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
finite
.param_str = "id"
.header = .math, .language = .gnu_lang
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
finitef
.param_str = "if"
.header = .math, .language = .gnu_lang
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
finitel
.param_str = "iLd"
.header = .math, .language = .gnu_lang
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
floor
.param_str = "dd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
floorf
.param_str = "ff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
floorl
.param_str = "LdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
fma
.param_str = "dddd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
fmaf
.param_str = "ffff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
fmal
.param_str = "LdLdLdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
fmax
.param_str = "ddd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
fmaxf
.param_str = "fff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
fmaxl
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
fmin
.param_str = "ddd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
fminf
.param_str = "fff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
fminl
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
fmod
.param_str = "ddd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
fmodf
.param_str = "fff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
fmodl
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
fopen
.param_str = "P*cC*cC*"
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true }
fprintf
.param_str = "iP*cC*."
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .printf, .format_string_position = 1 }
fread
.param_str = "zv*zzP*"
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true }
free
.param_str = "vv*"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
frexp
.param_str = "ddi*"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
frexpf
.param_str = "ffi*"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
frexpl
.param_str = "LdLdi*"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
fscanf
.param_str = "iP*RcC*R."
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .scanf, .format_string_position = 1 }
fwrite
.param_str = "zvC*zzP*"
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true }
getcontext
.param_str = "iK*"
.header = .setjmp
.attributes = .{ .allow_type_mismatch = true, .lib_function_without_prefix = true, .returns_twice = true }
hypot
.param_str = "ddd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
hypotf
.param_str = "fff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
hypotl
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ilogb
.param_str = "id"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ilogbf
.param_str = "if"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ilogbl
.param_str = "iLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
index
.param_str = "c*cC*i"
.header = .strings, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
isalnum
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
isalpha
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
isblank
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
iscntrl
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
isdigit
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
isgraph
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
islower
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
isprint
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
ispunct
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
isspace
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
isupper
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
isxdigit
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
labs
.param_str = "LiLi"
.header = .stdlib
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
ldexp
.param_str = "ddi"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ldexpf
.param_str = "ffi"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
ldexpl
.param_str = "LdLdi"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
lgamma
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
lgammaf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
lgammal
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
llabs
.param_str = "LLiLLi"
.header = .stdlib
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
llrint
.param_str = "LLid"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
llrintf
.param_str = "LLif"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
llrintl
.param_str = "LLiLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
llround
.param_str = "LLid"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
llroundf
.param_str = "LLif"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
llroundl
.param_str = "LLiLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
log
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
log10
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
log10f
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
log10l
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
log1p
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
log1pf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
log1pl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
log2
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
log2f
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
log2l
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
logb
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
logbf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
logbl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
logf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
logl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
longjmp
.param_str = "vJi"
.header = .setjmp
.attributes = .{ .noreturn = true, .allow_type_mismatch = true, .lib_function_without_prefix = true }
lrint
.param_str = "Lid"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
lrintf
.param_str = "Lif"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
lrintl
.param_str = "LiLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
lround
.param_str = "Lid"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
lroundf
.param_str = "Lif"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
lroundl
.param_str = "LiLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
malloc
.param_str = "v*z"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
memalign
.param_str = "v*zz"
.header = .malloc, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
memccpy
.param_str = "v*v*vC*iz"
.header = .string, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
memchr
.param_str = "v*vC*iz"
.header = .string
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
memcmp
.param_str = "ivC*vC*z"
.header = .string
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
memcpy
.param_str = "v*v*vC*z"
.header = .string
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
memmove
.param_str = "v*v*vC*z"
.header = .string
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
mempcpy
.param_str = "v*v*vC*z"
.header = .string, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
memset
.param_str = "v*v*iz"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
modf
.param_str = "ddd*"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
modff
.param_str = "fff*"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
modfl
.param_str = "LdLdLd*"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
nan
.param_str = "dcC*"
.header = .math
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
nanf
.param_str = "fcC*"
.header = .math
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
nanl
.param_str = "LdcC*"
.header = .math
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
nearbyint
.param_str = "dd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
nearbyintf
.param_str = "ff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
nearbyintl
.param_str = "LdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
nextafter
.param_str = "ddd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
nextafterf
.param_str = "fff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
nextafterl
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
nexttoward
.param_str = "ddLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
nexttowardf
.param_str = "ffLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
nexttowardl
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
pow
.param_str = "ddd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
powf
.param_str = "fff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
powl
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
printf
.param_str = "icC*."
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .printf }
realloc
.param_str = "v*v*z"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
remainder
.param_str = "ddd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
remainderf
.param_str = "fff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
remainderl
.param_str = "LdLdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
remquo
.param_str = "dddi*"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
remquof
.param_str = "fffi*"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
remquol
.param_str = "LdLdLdi*"
.header = .math
.attributes = .{ .lib_function_without_prefix = true }
rindex
.param_str = "c*cC*i"
.header = .strings, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
rint
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_fp_exceptions = true }
rintf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_fp_exceptions = true }
rintl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_fp_exceptions = true }
round
.param_str = "dd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
roundeven
.param_str = "dd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
roundevenf
.param_str = "ff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
roundevenl
.param_str = "LdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
roundf
.param_str = "ff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
roundl
.param_str = "LdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
savectx
.param_str = "iJ"
.header = .setjmp
.attributes = .{ .allow_type_mismatch = true, .lib_function_without_prefix = true, .returns_twice = true }
scalbln
.param_str = "ddLi"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
scalblnf
.param_str = "ffLi"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
scalblnl
.param_str = "LdLdLi"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
scalbn
.param_str = "ddi"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
scalbnf
.param_str = "ffi"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
scalbnl
.param_str = "LdLdi"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
scanf
.param_str = "icC*R."
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .scanf }
setjmp
.param_str = "iJ"
.header = .setjmp
.attributes = .{ .allow_type_mismatch = true, .lib_function_without_prefix = true, .returns_twice = true }
siglongjmp
.param_str = "vSJi"
.header = .setjmp, .language = .all_gnu_languages
.attributes = .{ .noreturn = true, .allow_type_mismatch = true, .lib_function_without_prefix = true }
sigsetjmp
.param_str = "iSJi"
.header = .setjmp
.attributes = .{ .allow_type_mismatch = true, .lib_function_without_prefix = true, .returns_twice = true }
sin
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
sinf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
sinh
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
sinhf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
sinhl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
sinl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
snprintf
.param_str = "ic*zcC*."
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .printf, .format_string_position = 2 }
sprintf
.param_str = "ic*cC*."
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .printf, .format_string_position = 1 }
sqrt
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
sqrtf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
sqrtl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
sscanf
.param_str = "icC*RcC*R."
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .scanf, .format_string_position = 1 }
stpcpy
.param_str = "c*c*cC*"
.header = .string, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
stpncpy
.param_str = "c*c*cC*z"
.header = .string, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
strcasecmp
.param_str = "icC*cC*"
.header = .strings, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
strcat
.param_str = "c*c*cC*"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strchr
.param_str = "c*cC*i"
.header = .string
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
strcmp
.param_str = "icC*cC*"
.header = .string
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
strcpy
.param_str = "c*c*cC*"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strcspn
.param_str = "zcC*cC*"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strdup
.param_str = "c*cC*"
.header = .string, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
strerror
.param_str = "c*i"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strlcat
.param_str = "zc*cC*z"
.header = .string, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
strlcpy
.param_str = "zc*cC*z"
.header = .string, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
strlen
.param_str = "zcC*"
.header = .string
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
strncasecmp
.param_str = "icC*cC*z"
.header = .strings, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
strncat
.param_str = "c*c*cC*z"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strncmp
.param_str = "icC*cC*z"
.header = .string
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
strncpy
.param_str = "c*c*cC*z"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strndup
.param_str = "c*cC*z"
.header = .string, .language = .all_gnu_languages
.attributes = .{ .lib_function_without_prefix = true }
strpbrk
.param_str = "c*cC*cC*"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strrchr
.param_str = "c*cC*i"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strspn
.param_str = "zcC*cC*"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strstr
.param_str = "c*cC*cC*"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strtod
.param_str = "dcC*c**"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
strtof
.param_str = "fcC*c**"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
strtok
.param_str = "c*c*cC*"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
strtol
.param_str = "LicC*c**i"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
strtold
.param_str = "LdcC*c**"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
strtoll
.param_str = "LLicC*c**i"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
strtoul
.param_str = "ULicC*c**i"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
strtoull
.param_str = "ULLicC*c**i"
.header = .stdlib
.attributes = .{ .lib_function_without_prefix = true }
strxfrm
.param_str = "zc*cC*z"
.header = .string
.attributes = .{ .lib_function_without_prefix = true }
tan
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
tanf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
tanh
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
tanhf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
tanhl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
tanl
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
tgamma
.param_str = "dd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
tgammaf
.param_str = "ff"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
tgammal
.param_str = "LdLd"
.header = .math
.attributes = .{ .lib_function_without_prefix = true, .const_without_errno_and_fp_exceptions = true }
tolower
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
toupper
.param_str = "ii"
.header = .ctype
.attributes = .{ .pure = true, .lib_function_without_prefix = true }
trunc
.param_str = "dd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
truncf
.param_str = "ff"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
truncl
.param_str = "LdLd"
.header = .math
.attributes = .{ .@"const" = true, .lib_function_without_prefix = true }
va_copy
.param_str = "vAA"
.header = .stdarg
.attributes = .{ .lib_function_without_prefix = true }
va_end
.param_str = "vA"
.header = .stdarg
.attributes = .{ .lib_function_without_prefix = true }
va_start
.param_str = "vA."
.header = .stdarg
.attributes = .{ .lib_function_without_prefix = true }
vfork
.param_str = "p"
.header = .unistd
.attributes = .{ .allow_type_mismatch = true, .lib_function_without_prefix = true, .returns_twice = true }
vfprintf
.param_str = "iP*cC*a"
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .vprintf, .format_string_position = 1 }
vfscanf
.param_str = "iP*RcC*Ra"
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .vscanf, .format_string_position = 1 }
vprintf
.param_str = "icC*a"
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .vprintf }
vscanf
.param_str = "icC*Ra"
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .vscanf }
vsnprintf
.param_str = "ic*zcC*a"
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .vprintf, .format_string_position = 2 }
vsprintf
.param_str = "ic*cC*a"
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .vprintf, .format_string_position = 1 }
vsscanf
.param_str = "icC*RcC*Ra"
.header = .stdio
.attributes = .{ .lib_function_without_prefix = true, .format_kind = .vscanf, .format_string_position = 1 }
wcschr
.param_str = "w*wC*w"
.header = .wchar
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
wcscmp
.param_str = "iwC*wC*"
.header = .wchar
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
wcslen
.param_str = "zwC*"
.header = .wchar
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
wcsncmp
.param_str = "iwC*wC*z"
.header = .wchar
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
wmemchr
.param_str = "w*wC*wz"
.header = .wchar
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
wmemcmp
.param_str = "iwC*wC*z"
.header = .wchar
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
wmemcpy
.param_str = "w*w*wC*z"
.header = .wchar
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
wmemmove
.param_str = "w*w*wC*z"
.header = .wchar
.attributes = .{ .lib_function_without_prefix = true, .const_evaluable = true }
# C11 _Atomic operations for <stdatomic.h>.
__c11_atomic_init
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_load
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_store
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_exchange
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_compare_exchange_strong
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_compare_exchange_weak
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_fetch_add
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_fetch_sub
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_fetch_and
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_fetch_or
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_fetch_xor
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_fetch_nand
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_fetch_max
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__c11_atomic_fetch_min
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
# GNU atomics
__atomic_load
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_load_n
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_store
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_store_n
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_exchange
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_exchange_n
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_compare_exchange
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_compare_exchange_n
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_fetch_add
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_fetch_sub
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_fetch_and
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_fetch_or
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_fetch_xor
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_fetch_nand
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_add_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_sub_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_and_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_or_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_xor_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_max_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_min_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_nand_fetch
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
# clang extensions
__atomic_fetch_min
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
__atomic_fetch_max
.param_str = "v."
.attributes = .{ .custom_typecheck = true }
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Builtins/Properties.zig | const std = @import("std");
const Properties = @This();
param_str: []const u8,
language: Language = .all_languages,
attributes: Attributes = Attributes{},
header: Header = .none,
target_set: TargetSet = TargetSet.initOne(.basic),
/// Header which must be included for a builtin to be available
pub const Header = enum {
none,
/// stdio.h
stdio,
/// stdlib.h
stdlib,
/// setjmpex.h
setjmpex,
/// stdarg.h
stdarg,
/// string.h
string,
/// ctype.h
ctype,
/// wchar.h
wchar,
/// setjmp.h
setjmp,
/// malloc.h
malloc,
/// strings.h
strings,
/// unistd.h
unistd,
/// pthread.h
pthread,
/// math.h
math,
/// complex.h
complex,
/// Blocks.h
blocks,
};
/// Languages in which a builtin is available
pub const Language = enum {
all_languages,
all_ms_languages,
all_gnu_languages,
gnu_lang,
};
pub const Attributes = packed struct {
/// Function does not return
noreturn: bool = false,
/// Function has no side effects
pure: bool = false,
/// Function has no side effects and does not read memory
@"const": bool = false,
/// Signature is meaningless; use custom typecheck
custom_typecheck: bool = false,
/// A declaration of this builtin should be recognized even if the type doesn't match the specified signature.
allow_type_mismatch: bool = false,
/// this is a libc/libm function with a '__builtin_' prefix added.
lib_function_with_builtin_prefix: bool = false,
/// this is a libc/libm function without a '__builtin_' prefix. This builtin is disableable by '-fno-builtin-foo'
lib_function_without_prefix: bool = false,
/// Function returns twice (e.g. setjmp)
returns_twice: bool = false,
/// Nature of the format string passed to this function
format_kind: enum(u3) {
/// Does not take a format string
none,
/// this is a printf-like function whose Nth argument is the format string
printf,
/// function is like vprintf in that it accepts its arguments as a va_list rather than through an ellipsis
vprintf,
/// this is a scanf-like function whose Nth argument is the format string
scanf,
/// the function is like vscanf in that it accepts its arguments as a va_list rather than through an ellipsis
vscanf,
} = .none,
/// Position of format string argument. Only meaningful if format_kind is not .none
format_string_position: u5 = 0,
/// if false, arguments are not evaluated
eval_args: bool = true,
/// no side effects and does not read memory, but only when -fno-math-errno and FP exceptions are ignored
const_without_errno_and_fp_exceptions: bool = false,
/// no side effects and does not read memory, but only when FP exceptions are ignored
const_without_fp_exceptions: bool = false,
/// this function can be constant evaluated by the frontend
const_evaluable: bool = false,
};
pub const Target = enum {
/// Supported on all targets
basic,
aarch64,
aarch64_neon_sve_bridge,
aarch64_neon_sve_bridge_cg,
amdgpu,
arm,
bpf,
hexagon,
hexagon_dep,
hexagon_map_custom_dep,
loong_arch,
mips,
neon,
nvptx,
ppc,
riscv,
riscv_vector,
sve,
systemz,
ve,
vevl_gen,
webassembly,
x86,
x86_64,
xcore,
};
/// Targets for which a builtin is enabled
pub const TargetSet = std.enums.EnumSet(Target);
pub fn isVarArgs(properties: Properties) bool {
return properties.param_str[properties.param_str.len - 1] == '.';
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Builtins/eval.zig | const std = @import("std");
const backend = @import("backend");
const Interner = backend.Interner;
const Builtins = @import("../Builtins.zig");
const Builtin = Builtins.Builtin;
const Parser = @import("../Parser.zig");
const Tree = @import("../Tree.zig");
const NodeIndex = Tree.NodeIndex;
const Type = @import("../Type.zig");
const Value = @import("../Value.zig");
fn makeNan(comptime T: type, str: []const u8) T {
const UnsignedSameSize = std.meta.Int(.unsigned, @bitSizeOf(T));
const parsed = std.fmt.parseUnsigned(UnsignedSameSize, str[0 .. str.len - 1], 0) catch 0;
const bits: switch (T) {
f32 => u23,
f64 => u52,
f80 => u63,
f128 => u112,
else => @compileError("Invalid type for makeNan"),
} = @truncate(parsed);
return @bitCast(@as(UnsignedSameSize, bits) | @as(UnsignedSameSize, @bitCast(std.math.nan(T))));
}
pub fn eval(tag: Builtin.Tag, p: *Parser, args: []const NodeIndex) !Value {
const builtin = Builtin.fromTag(tag);
if (!builtin.properties.attributes.const_evaluable) return .{};
switch (tag) {
Builtin.tagFromName("__builtin_inff").?,
Builtin.tagFromName("__builtin_inf").?,
Builtin.tagFromName("__builtin_infl").?,
=> {
const ty: Type = switch (tag) {
Builtin.tagFromName("__builtin_inff").? => .{ .specifier = .float },
Builtin.tagFromName("__builtin_inf").? => .{ .specifier = .double },
Builtin.tagFromName("__builtin_infl").? => .{ .specifier = .long_double },
else => unreachable,
};
const f: Interner.Key.Float = switch (ty.bitSizeof(p.comp).?) {
32 => .{ .f32 = std.math.inf(f32) },
64 => .{ .f64 = std.math.inf(f64) },
80 => .{ .f80 = std.math.inf(f80) },
128 => .{ .f128 = std.math.inf(f128) },
else => unreachable,
};
return Value.intern(p.comp, .{ .float = f });
},
Builtin.tagFromName("__builtin_isinf").? => blk: {
if (args.len == 0) break :blk;
const val = p.value_map.get(args[0]) orelse break :blk;
return Value.fromBool(val.isInf(p.comp));
},
Builtin.tagFromName("__builtin_isinf_sign").? => blk: {
if (args.len == 0) break :blk;
const val = p.value_map.get(args[0]) orelse break :blk;
switch (val.isInfSign(p.comp)) {
.unknown => {},
.finite => return Value.zero,
.positive => return Value.one,
.negative => return Value.int(@as(i64, -1), p.comp),
}
},
Builtin.tagFromName("__builtin_isnan").? => blk: {
if (args.len == 0) break :blk;
const val = p.value_map.get(args[0]) orelse break :blk;
return Value.fromBool(val.isNan(p.comp));
},
Builtin.tagFromName("__builtin_nan").? => blk: {
if (args.len == 0) break :blk;
const val = p.getDecayedStringLiteral(args[0]) orelse break :blk;
const bytes = p.comp.interner.get(val.ref()).bytes;
const f: Interner.Key.Float = switch ((Type{ .specifier = .double }).bitSizeof(p.comp).?) {
32 => .{ .f32 = makeNan(f32, bytes) },
64 => .{ .f64 = makeNan(f64, bytes) },
80 => .{ .f80 = makeNan(f80, bytes) },
128 => .{ .f128 = makeNan(f128, bytes) },
else => unreachable,
};
return Value.intern(p.comp, .{ .float = f });
},
else => {},
}
return .{};
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Diagnostics/messages.def | const W = Properties.makeOpt;
const pointer_sign_message = " converts between pointers to integer types with different sign";
# Maybe someday this will no longer be needed.
todo
.msg = "TODO: {s}"
.extra = .str
.kind = .@"error"
error_directive
.msg = "{s}"
.extra = .str
.kind = .@"error"
warning_directive
.msg = "{s}"
.opt = W("#warnings")
.extra = .str
.kind = .warning
elif_without_if
.msg = "#elif without #if"
.kind = .@"error"
elif_after_else
.msg = "#elif after #else"
.kind = .@"error"
elifdef_without_if
.msg = "#elifdef without #if"
.kind = .@"error"
elifdef_after_else
.msg = "#elifdef after #else"
.kind = .@"error"
elifndef_without_if
.msg = "#elifndef without #if"
.kind = .@"error"
elifndef_after_else
.msg = "#elifndef after #else"
.kind = .@"error"
else_without_if
.msg = "#else without #if"
.kind = .@"error"
else_after_else
.msg = "#else after #else"
.kind = .@"error"
endif_without_if
.msg = "#endif without #if"
.kind = .@"error"
unknown_pragma
.msg = "unknown pragma ignored"
.opt = W("unknown-pragmas")
.kind = .off
.all = true
line_simple_digit
.msg = "#line directive requires a simple digit sequence"
.kind = .@"error"
line_invalid_filename
.msg = "invalid filename for #line directive"
.kind = .@"error"
unterminated_conditional_directive
.msg = "unterminated conditional directive"
.kind = .@"error"
invalid_preprocessing_directive
.msg = "invalid preprocessing directive"
.kind = .@"error"
macro_name_missing
.msg = "macro name missing"
.kind = .@"error"
extra_tokens_directive_end
.msg = "extra tokens at end of macro directive"
.kind = .@"error"
expected_value_in_expr
.msg = "expected value in expression"
.kind = .@"error"
closing_paren
.msg = "expected closing ')'"
.kind = .@"error"
to_match_paren
.msg = "to match this '('"
.kind = .note
to_match_brace
.msg = "to match this '{'"
.kind = .note
to_match_bracket
.msg = "to match this '['"
.kind = .note
header_str_closing
.msg = "expected closing '>'"
.kind = .@"error"
header_str_match
.msg = "to match this '<'"
.kind = .note
string_literal_in_pp_expr
.msg = "string literal in preprocessor expression"
.kind = .@"error"
float_literal_in_pp_expr
.msg = "floating point literal in preprocessor expression"
.kind = .@"error"
defined_as_macro_name
.msg = "'defined' cannot be used as a macro name"
.kind = .@"error"
macro_name_must_be_identifier
.msg = "macro name must be an identifier"
.kind = .@"error"
whitespace_after_macro_name
.msg = "ISO C99 requires whitespace after the macro name"
.opt = W("c99-extensions")
.kind = .warning
hash_hash_at_start
.msg = "'##' cannot appear at the start of a macro expansion"
.kind = .@"error"
hash_hash_at_end
.msg = "'##' cannot appear at the end of a macro expansion"
.kind = .@"error"
pasting_formed_invalid
.msg = "pasting formed '{s}', an invalid preprocessing token"
.extra = .str
.kind = .@"error"
missing_paren_param_list
.msg = "missing ')' in macro parameter list"
.kind = .@"error"
unterminated_macro_param_list
.msg = "unterminated macro param list"
.kind = .@"error"
invalid_token_param_list
.msg = "invalid token in macro parameter list"
.kind = .@"error"
expected_comma_param_list
.msg = "expected comma in macro parameter list"
.kind = .@"error"
hash_not_followed_param
.msg = "'#' is not followed by a macro parameter"
.kind = .@"error"
expected_filename
.msg = "expected \"FILENAME\" or <FILENAME>"
.kind = .@"error"
empty_filename
.msg = "empty filename"
.kind = .@"error"
expected_invalid
.msg = "expected '{s}', found invalid bytes"
.extra = .tok_id_expected
.kind = .@"error"
expected_eof
.msg = "expected '{s}' before end of file"
.extra = .tok_id_expected
.kind = .@"error"
expected_token
.msg = "expected '{s}', found '{s}'"
.extra = .tok_id
.kind = .@"error"
expected_expr
.msg = "expected expression"
.kind = .@"error"
expected_integer_constant_expr
.msg = "expression is not an integer constant expression"
.kind = .@"error"
missing_type_specifier
.msg = "type specifier missing, defaults to 'int'"
.opt = W("implicit-int")
.kind = .warning
.all = true
missing_type_specifier_c23
.msg = "a type specifier is required for all declarations"
.kind = .@"error"
multiple_storage_class
.msg = "cannot combine with previous '{s}' declaration specifier"
.extra = .str
.kind = .@"error"
static_assert_failure
.msg = "static assertion failed"
.kind = .@"error"
static_assert_failure_message
.msg = "static assertion failed {s}"
.extra = .str
.kind = .@"error"
expected_type
.msg = "expected a type"
.kind = .@"error"
cannot_combine_spec
.msg = "cannot combine with previous '{s}' specifier"
.extra = .str
.kind = .@"error"
duplicate_decl_spec
.msg = "duplicate '{s}' declaration specifier"
.extra = .str
.opt = W("duplicate-decl-specifier")
.kind = .warning
.all = true
restrict_non_pointer
.msg = "restrict requires a pointer or reference ('{s}' is invalid)"
.extra = .str
.kind = .@"error"
expected_external_decl
.msg = "expected external declaration"
.kind = .@"error"
expected_ident_or_l_paren
.msg = "expected identifier or '('"
.kind = .@"error"
missing_declaration
.msg = "declaration does not declare anything"
.opt = W("missing-declaration")
.kind = .warning
func_not_in_root
.msg = "function definition is not allowed here"
.kind = .@"error"
illegal_initializer
.msg = "illegal initializer (only variables can be initialized)"
.kind = .@"error"
extern_initializer
.msg = "extern variable has initializer"
.opt = W("extern-initializer")
.kind = .warning
spec_from_typedef
.msg = "'{s}' came from typedef"
.extra = .str
.kind = .note
param_before_var_args
.msg = "ISO C requires a named parameter before '...'"
.kind = .@"error"
.suppress_version = .c23
void_only_param
.msg = "'void' must be the only parameter if specified"
.kind = .@"error"
void_param_qualified
.msg = "'void' parameter cannot be qualified"
.kind = .@"error"
void_must_be_first_param
.msg = "'void' must be the first parameter if specified"
.kind = .@"error"
invalid_storage_on_param
.msg = "invalid storage class on function parameter"
.kind = .@"error"
threadlocal_non_var
.msg = "_Thread_local only allowed on variables"
.kind = .@"error"
func_spec_non_func
.msg = "'{s}' can only appear on functions"
.extra = .str
.kind = .@"error"
illegal_storage_on_func
.msg = "illegal storage class on function"
.kind = .@"error"
illegal_storage_on_global
.msg = "illegal storage class on global variable"
.kind = .@"error"
expected_stmt
.msg = "expected statement"
.kind = .@"error"
func_cannot_return_func
.msg = "function cannot return a function"
.kind = .@"error"
func_cannot_return_array
.msg = "function cannot return an array"
.kind = .@"error"
undeclared_identifier
.msg = "use of undeclared identifier '{s}'"
.extra = .str
.kind = .@"error"
not_callable
.msg = "cannot call non function type '{s}'"
.extra = .str
.kind = .@"error"
unsupported_str_cat
.msg = "unsupported string literal concatenation"
.kind = .@"error"
static_func_not_global
.msg = "static functions must be global"
.kind = .@"error"
implicit_func_decl
.msg = "call to undeclared function '{s}'; ISO C99 and later do not support implicit function declarations"
.extra = .str
.opt = W("implicit-function-declaration")
.kind = .@"error"
.all = true
unknown_builtin
.msg = "use of unknown builtin '{s}'"
.extra = .str
.opt = W("implicit-function-declaration")
.kind = .@"error"
.all = true
implicit_builtin
.msg = "implicitly declaring library function '{s}'"
.extra = .str
.opt = W("implicit-function-declaration")
.kind = .@"error"
.all = true
implicit_builtin_header_note
.msg = "include the header <{s}.h> or explicitly provide a declaration for '{s}'"
.extra = .builtin_with_header
.opt = W("implicit-function-declaration")
.kind = .note
.all = true
expected_param_decl
.msg = "expected parameter declaration"
.kind = .@"error"
invalid_old_style_params
.msg = "identifier parameter lists are only allowed in function definitions"
.kind = .@"error"
expected_fn_body
.msg = "expected function body after function declaration"
.kind = .@"error"
invalid_void_param
.msg = "parameter cannot have void type"
.kind = .@"error"
unused_value
.msg = "expression result unused"
.opt = W("unused-value")
.kind = .warning
.all = true
continue_not_in_loop
.msg = "'continue' statement not in a loop"
.kind = .@"error"
break_not_in_loop_or_switch
.msg = "'break' statement not in a loop or a switch"
.kind = .@"error"
unreachable_code
.msg = "unreachable code"
.opt = W("unreachable-code")
.kind = .warning
.all = true
duplicate_label
.msg = "duplicate label '{s}'"
.extra = .str
.kind = .@"error"
previous_label
.msg = "previous definition of label '{s}' was here"
.extra = .str
.kind = .note
undeclared_label
.msg = "use of undeclared label '{s}'"
.extra = .str
.kind = .@"error"
case_not_in_switch
.msg = "'{s}' statement not in a switch statement"
.extra = .str
.kind = .@"error"
duplicate_switch_case
.msg = "duplicate case value '{s}'"
.extra = .str
.kind = .@"error"
multiple_default
.msg = "multiple default cases in the same switch"
.kind = .@"error"
previous_case
.msg = "previous case defined here"
.kind = .note
const expected_arguments = "expected {d} argument(s) got {d}";
expected_arguments
.msg = expected_arguments
.extra = .arguments
.kind = .@"error"
callee_with_static_array
.msg = "callee declares array parameter as static here"
.kind = .note
array_argument_too_small
.msg = "array argument is too small; contains {d} elements, callee requires at least {d}"
.extra = .arguments
.kind = .warning
.opt = W("array-bounds")
non_null_argument
.msg = "null passed to a callee that requires a non-null argument"
.kind = .warning
.opt = W("nonnull")
expected_arguments_old
.msg = expected_arguments
.extra = .arguments
.kind = .warning
expected_at_least_arguments
.msg = "expected at least {d} argument(s) got {d}"
.extra = .arguments
.kind = .warning
invalid_static_star
.msg = "'static' may not be used with an unspecified variable length array size"
.kind = .@"error"
static_non_param
.msg = "'static' used outside of function parameters"
.kind = .@"error"
array_qualifiers
.msg = "type qualifier in non parameter array type"
.kind = .@"error"
star_non_param
.msg = "star modifier used outside of function parameters"
.kind = .@"error"
variable_len_array_file_scope
.msg = "variable length arrays not allowed at file scope"
.kind = .@"error"
useless_static
.msg = "'static' useless without a constant size"
.kind = .warning
.w_extra = true
negative_array_size
.msg = "array size must be 0 or greater"
.kind = .@"error"
array_incomplete_elem
.msg = "array has incomplete element type '{s}'"
.extra = .str
.kind = .@"error"
array_func_elem
.msg = "arrays cannot have functions as their element type"
.kind = .@"error"
static_non_outermost_array
.msg = "'static' used in non-outermost array type"
.kind = .@"error"
qualifier_non_outermost_array
.msg = "type qualifier used in non-outermost array type"
.kind = .@"error"
unterminated_macro_arg_list
.msg = "unterminated function macro argument list"
.kind = .@"error"
unknown_warning
.msg = "unknown warning '{s}'"
.extra = .str
.opt = W("unknown-warning-option")
.kind = .warning
overflow
.msg = "overflow in expression; result is '{s}'"
.extra = .str
.opt = W("integer-overflow")
.kind = .warning
int_literal_too_big
.msg = "integer literal is too large to be represented in any integer type"
.kind = .@"error"
indirection_ptr
.msg = "indirection requires pointer operand"
.kind = .@"error"
addr_of_rvalue
.msg = "cannot take the address of an rvalue"
.kind = .@"error"
addr_of_bitfield
.msg = "address of bit-field requested"
.kind = .@"error"
not_assignable
.msg = "expression is not assignable"
.kind = .@"error"
ident_or_l_brace
.msg = "expected identifier or '{'"
.kind = .@"error"
empty_enum
.msg = "empty enum is invalid"
.kind = .@"error"
redefinition
.msg = "redefinition of '{s}'"
.extra = .str
.kind = .@"error"
previous_definition
.msg = "previous definition is here"
.kind = .note
expected_identifier
.msg = "expected identifier"
.kind = .@"error"
expected_str_literal
.msg = "expected string literal for diagnostic message in static_assert"
.kind = .@"error"
expected_str_literal_in
.msg = "expected string literal in '{s}'"
.extra = .str
.kind = .@"error"
parameter_missing
.msg = "parameter named '{s}' is missing"
.extra = .str
.kind = .@"error"
empty_record
.msg = "empty {s} is a GNU extension"
.extra = .str
.opt = W("gnu-empty-struct")
.kind = .off
.pedantic = true
empty_record_size
.msg = "empty {s} has size 0 in C, size 1 in C++"
.extra = .str
.opt = W("c++-compat")
.kind = .off
wrong_tag
.msg = "use of '{s}' with tag type that does not match previous definition"
.extra = .str
.kind = .@"error"
expected_parens_around_typename
.msg = "expected parentheses around type name"
.kind = .@"error"
alignof_expr
.msg = "'_Alignof' applied to an expression is a GNU extension"
.opt = W("gnu-alignof-expression")
.kind = .warning
.suppress_gnu = true
invalid_alignof
.msg = "invalid application of 'alignof' to an incomplete type '{s}'"
.extra = .str
.kind = .@"error"
invalid_sizeof
.msg = "invalid application of 'sizeof' to an incomplete type '{s}'"
.extra = .str
.kind = .@"error"
macro_redefined
.msg = "'{s}' macro redefined"
.extra = .str
.opt = W("macro-redefined")
.kind = .warning
generic_qual_type
.msg = "generic association with qualifiers cannot be matched with"
.opt = W("generic-qual-type")
.kind = .warning
generic_array_type
.msg = "generic association array type cannot be matched with"
.opt = W("generic-qual-type")
.kind = .warning
generic_func_type
.msg = "generic association function type cannot be matched with"
.opt = W("generic-qual-type")
.kind = .warning
generic_duplicate
.msg = "type '{s}' in generic association compatible with previously specified type"
.extra = .str
.kind = .@"error"
generic_duplicate_here
.msg = "compatible type '{s}' specified here"
.extra = .str
.kind = .note
generic_duplicate_default
.msg = "duplicate default generic association"
.kind = .@"error"
generic_no_match
.msg = "controlling expression type '{s}' not compatible with any generic association type"
.extra = .str
.kind = .@"error"
escape_sequence_overflow
.msg = "escape sequence out of range"
.kind = .@"error"
invalid_universal_character
.msg = "invalid universal character"
.kind = .@"error"
incomplete_universal_character
.msg = "incomplete universal character name"
.kind = .@"error"
multichar_literal_warning
.msg = "multi-character character constant"
.opt = W("multichar")
.kind = .warning
.all = true
invalid_multichar_literal
.msg = "{s} character literals may not contain multiple characters"
.kind = .@"error"
.extra = .str
wide_multichar_literal
.msg = "extraneous characters in character constant ignored"
.kind = .warning
char_lit_too_wide
.msg = "character constant too long for its type"
.kind = .warning
.all = true
char_too_large
.msg = "character too large for enclosing character literal type"
.kind = .@"error"
must_use_struct
.msg = "must use 'struct' tag to refer to type '{s}'"
.extra = .str
.kind = .@"error"
must_use_union
.msg = "must use 'union' tag to refer to type '{s}'"
.extra = .str
.kind = .@"error"
must_use_enum
.msg = "must use 'enum' tag to refer to type '{s}'"
.extra = .str
.kind = .@"error"
redefinition_different_sym
.msg = "redefinition of '{s}' as different kind of symbol"
.extra = .str
.kind = .@"error"
redefinition_incompatible
.msg = "redefinition of '{s}' with a different type"
.extra = .str
.kind = .@"error"
redefinition_of_parameter
.msg = "redefinition of parameter '{s}'"
.extra = .str
.kind = .@"error"
invalid_bin_types
.msg = "invalid operands to binary expression ({s})"
.extra = .str
.kind = .@"error"
comparison_ptr_int
.msg = "comparison between pointer and integer ({s})"
.extra = .str
.opt = W("pointer-integer-compare")
.kind = .warning
comparison_distinct_ptr
.msg = "comparison of distinct pointer types ({s})"
.extra = .str
.opt = W("compare-distinct-pointer-types")
.kind = .warning
incompatible_pointers
.msg = "incompatible pointer types ({s})"
.extra = .str
.kind = .@"error"
invalid_argument_un
.msg = "invalid argument type '{s}' to unary expression"
.extra = .str
.kind = .@"error"
incompatible_assign
.msg = "assignment to {s}"
.extra = .str
.kind = .@"error"
implicit_ptr_to_int
.msg = "implicit pointer to integer conversion from {s}"
.extra = .str
.opt = W("int-conversion")
.kind = .warning
invalid_cast_to_float
.msg = "pointer cannot be cast to type '{s}'"
.extra = .str
.kind = .@"error"
invalid_cast_to_pointer
.msg = "operand of type '{s}' cannot be cast to a pointer type"
.extra = .str
.kind = .@"error"
invalid_cast_type
.msg = "cannot cast to non arithmetic or pointer type '{s}'"
.extra = .str
.kind = .@"error"
qual_cast
.msg = "cast to type '{s}' will not preserve qualifiers"
.extra = .str
.opt = W("cast-qualifiers")
.kind = .warning
invalid_index
.msg = "array subscript is not an integer"
.kind = .@"error"
invalid_subscript
.msg = "subscripted value is not an array or pointer"
.kind = .@"error"
array_after
.msg = "array index {s} is past the end of the array"
.extra = .str
.opt = W("array-bounds")
.kind = .warning
array_before
.msg = "array index {s} is before the beginning of the array"
.extra = .str
.opt = W("array-bounds")
.kind = .warning
statement_int
.msg = "statement requires expression with integer type ('{s}' invalid)"
.extra = .str
.kind = .@"error"
statement_scalar
.msg = "statement requires expression with scalar type ('{s}' invalid)"
.extra = .str
.kind = .@"error"
func_should_return
.msg = "non-void function '{s}' should return a value"
.extra = .str
.opt = W("return-type")
.kind = .@"error"
.all = true
incompatible_return
.msg = "returning {s}"
.extra = .str
.kind = .@"error"
incompatible_return_sign
.msg = "returning {s}" ++ pointer_sign_message
.extra = .str
.kind = .warning
.opt = W("pointer-sign")
implicit_int_to_ptr
.msg = "implicit integer to pointer conversion from {s}"
.extra = .str
.opt = W("int-conversion")
.kind = .warning
func_does_not_return
.msg = "non-void function '{s}' does not return a value"
.extra = .str
.opt = W("return-type")
.kind = .warning
.all = true
void_func_returns_value
.msg = "void function '{s}' should not return a value"
.extra = .str
.opt = W("return-type")
.kind = .@"error"
.all = true
incompatible_arg
.msg = "passing {s}"
.extra = .str
.kind = .@"error"
incompatible_ptr_arg
.msg = "passing {s}"
.extra = .str
.kind = .warning
.opt = W("incompatible-pointer-types")
incompatible_ptr_arg_sign
.msg = "passing {s}" ++ pointer_sign_message
.extra = .str
.kind = .warning
.opt = W("pointer-sign")
parameter_here
.msg = "passing argument to parameter here"
.kind = .note
atomic_array
.msg = "atomic cannot be applied to array type '{s}'"
.extra = .str
.kind = .@"error"
atomic_func
.msg = "atomic cannot be applied to function type '{s}'"
.extra = .str
.kind = .@"error"
atomic_incomplete
.msg = "atomic cannot be applied to incomplete type '{s}'"
.extra = .str
.kind = .@"error"
addr_of_register
.msg = "address of register variable requested"
.kind = .@"error"
variable_incomplete_ty
.msg = "variable has incomplete type '{s}'"
.extra = .str
.kind = .@"error"
parameter_incomplete_ty
.msg = "parameter has incomplete type '{s}'"
.extra = .str
.kind = .@"error"
tentative_array
.msg = "tentative array definition assumed to have one element"
.kind = .warning
deref_incomplete_ty_ptr
.msg = "dereferencing pointer to incomplete type '{s}'"
.extra = .str
.kind = .@"error"
alignas_on_func
.msg = "'_Alignas' attribute only applies to variables and fields"
.kind = .@"error"
alignas_on_param
.msg = "'_Alignas' attribute cannot be applied to a function parameter"
.kind = .@"error"
minimum_alignment
.msg = "requested alignment is less than minimum alignment of {d}"
.extra = .unsigned
.kind = .@"error"
maximum_alignment
.msg = "requested alignment of {s} is too large"
.extra = .str
.kind = .@"error"
negative_alignment
.msg = "requested negative alignment of {s} is invalid"
.extra = .str
.kind = .@"error"
align_ignored
.msg = "'_Alignas' attribute is ignored here"
.kind = .warning
zero_align_ignored
.msg = "requested alignment of zero is ignored"
.kind = .warning
non_pow2_align
.msg = "requested alignment is not a power of 2"
.kind = .@"error"
pointer_mismatch
.msg = "pointer type mismatch ({s})"
.extra = .str
.opt = W("pointer-type-mismatch")
.kind = .warning
static_assert_not_constant
.msg = "static_assert expression is not an integral constant expression"
.kind = .@"error"
static_assert_missing_message
.msg = "static_assert with no message is a C23 extension"
.opt = W("c23-extensions")
.kind = .warning
.suppress_version = .c23
pre_c23_compat
.msg = "{s} is incompatible with C standards before C23"
.extra = .str
.kind = .off
.suppress_unless_version = .c23
.opt = W("pre-c23-compat")
unbound_vla
.msg = "variable length array must be bound in function definition"
.kind = .@"error"
array_too_large
.msg = "array is too large"
.kind = .@"error"
record_too_large
.msg = "type '{s}' is too large"
.kind = .@"error"
.extra = .str
incompatible_ptr_init
.msg = "incompatible pointer types initializing {s}"
.extra = .str
.opt = W("incompatible-pointer-types")
.kind = .warning
incompatible_ptr_init_sign
.msg = "incompatible pointer types initializing {s}" ++ pointer_sign_message
.extra = .str
.opt = W("pointer-sign")
.kind = .warning
incompatible_ptr_assign
.msg = "incompatible pointer types assigning to {s}"
.extra = .str
.opt = W("incompatible-pointer-types")
.kind = .warning
incompatible_ptr_assign_sign
.msg = "incompatible pointer types assigning to {s} " ++ pointer_sign_message
.extra = .str
.opt = W("pointer-sign")
.kind = .warning
vla_init
.msg = "variable-sized object may not be initialized"
.kind = .@"error"
func_init
.msg = "illegal initializer type"
.kind = .@"error"
incompatible_init
.msg = "initializing {s}"
.extra = .str
.kind = .@"error"
empty_scalar_init
.msg = "scalar initializer cannot be empty"
.kind = .@"error"
excess_scalar_init
.msg = "excess elements in scalar initializer"
.opt = W("excess-initializers")
.kind = .warning
excess_str_init
.msg = "excess elements in string initializer"
.opt = W("excess-initializers")
.kind = .warning
excess_struct_init
.msg = "excess elements in struct initializer"
.opt = W("excess-initializers")
.kind = .warning
excess_array_init
.msg = "excess elements in array initializer"
.opt = W("excess-initializers")
.kind = .warning
str_init_too_long
.msg = "initializer-string for char array is too long"
.opt = W("excess-initializers")
.kind = .warning
arr_init_too_long
.msg = "cannot initialize type ({s})"
.extra = .str
.kind = .@"error"
invalid_typeof
.msg = "'{s} typeof' is invalid"
.extra = .str
.kind = .@"error"
division_by_zero
.msg = "{s} by zero is undefined"
.extra = .str
.opt = W("division-by-zero")
.kind = .warning
division_by_zero_macro
.msg = "{s} by zero in preprocessor expression"
.extra = .str
.kind = .@"error"
builtin_choose_cond
.msg = "'__builtin_choose_expr' requires a constant expression"
.kind = .@"error"
alignas_unavailable
.msg = "'_Alignas' attribute requires integer constant expression"
.kind = .@"error"
case_val_unavailable
.msg = "case value must be an integer constant expression"
.kind = .@"error"
enum_val_unavailable
.msg = "enum value must be an integer constant expression"
.kind = .@"error"
incompatible_array_init
.msg = "cannot initialize array of type {s}"
.extra = .str
.kind = .@"error"
array_init_str
.msg = "array initializer must be an initializer list or wide string literal"
.kind = .@"error"
initializer_overrides
.msg = "initializer overrides previous initialization"
.opt = W("initializer-overrides")
.kind = .warning
.w_extra = true
previous_initializer
.msg = "previous initialization"
.kind = .note
invalid_array_designator
.msg = "array designator used for non-array type '{s}'"
.extra = .str
.kind = .@"error"
negative_array_designator
.msg = "array designator value {s} is negative"
.extra = .str
.kind = .@"error"
oob_array_designator
.msg = "array designator index {s} exceeds array bounds"
.extra = .str
.kind = .@"error"
invalid_field_designator
.msg = "field designator used for non-record type '{s}'"
.extra = .str
.kind = .@"error"
no_such_field_designator
.msg = "record type has no field named '{s}'"
.extra = .str
.kind = .@"error"
empty_aggregate_init_braces
.msg = "initializer for aggregate with no elements requires explicit braces"
.kind = .@"error"
ptr_init_discards_quals
.msg = "initializing {s} discards qualifiers"
.extra = .str
.opt = W("incompatible-pointer-types-discards-qualifiers")
.kind = .warning
ptr_assign_discards_quals
.msg = "assigning to {s} discards qualifiers"
.extra = .str
.opt = W("incompatible-pointer-types-discards-qualifiers")
.kind = .warning
ptr_ret_discards_quals
.msg = "returning {s} discards qualifiers"
.extra = .str
.opt = W("incompatible-pointer-types-discards-qualifiers")
.kind = .warning
ptr_arg_discards_quals
.msg = "passing {s} discards qualifiers"
.extra = .str
.opt = W("incompatible-pointer-types-discards-qualifiers")
.kind = .warning
unknown_attribute
.msg = "unknown attribute '{s}' ignored"
.extra = .str
.opt = W("unknown-attributes")
.kind = .warning
ignored_attribute
.msg = "{s}"
.extra = .str
.opt = W("ignored-attributes")
.kind = .warning
invalid_fallthrough
.msg = "fallthrough annotation does not directly precede switch label"
.kind = .@"error"
cannot_apply_attribute_to_statement
.msg = "'{s}' attribute cannot be applied to a statement"
.extra = .str
.kind = .@"error"
builtin_macro_redefined
.msg = "redefining builtin macro"
.opt = W("builtin-macro-redefined")
.kind = .warning
feature_check_requires_identifier
.msg = "builtin feature check macro requires a parenthesized identifier"
.kind = .@"error"
missing_tok_builtin
.msg = "missing '{s}', after builtin feature-check macro"
.extra = .tok_id_expected
.kind = .@"error"
gnu_label_as_value
.msg = "use of GNU address-of-label extension"
.opt = W("gnu-label-as-value")
.kind = .off
.pedantic = true
expected_record_ty
.msg = "member reference base type '{s}' is not a structure or union"
.extra = .str
.kind = .@"error"
member_expr_not_ptr
.msg = "member reference type '{s}' is not a pointer; did you mean to use '.'?"
.extra = .str
.kind = .@"error"
member_expr_ptr
.msg = "member reference type '{s}' is a pointer; did you mean to use '->'?"
.extra = .str
.kind = .@"error"
no_such_member
.msg = "no member named {s}"
.extra = .str
.kind = .@"error"
malformed_warning_check
.msg = "{s} expected option name (e.g. \"-Wundef\")"
.extra = .str
.opt = W("malformed-warning-check")
.kind = .warning
.all = true
invalid_computed_goto
.msg = "computed goto in function with no address-of-label expressions"
.kind = .@"error"
pragma_warning_message
.msg = "{s}"
.extra = .str
.opt = W("#pragma-messages")
.kind = .warning
pragma_error_message
.msg = "{s}"
.extra = .str
.kind = .@"error"
pragma_message
.msg = "#pragma message: {s}"
.extra = .str
.kind = .note
pragma_requires_string_literal
.msg = "pragma {s} requires string literal"
.extra = .str
.kind = .@"error"
poisoned_identifier
.msg = "attempt to use a poisoned identifier"
.kind = .@"error"
pragma_poison_identifier
.msg = "can only poison identifier tokens"
.kind = .@"error"
pragma_poison_macro
.msg = "poisoning existing macro"
.kind = .warning
newline_eof
.msg = "no newline at end of file"
.opt = W("newline-eof")
.kind = .off
.pedantic = true
empty_translation_unit
.msg = "ISO C requires a translation unit to contain at least one declaration"
.opt = W("empty-translation-unit")
.kind = .off
.pedantic = true
omitting_parameter_name
.msg = "omitting the parameter name in a function definition is a C23 extension"
.opt = W("c23-extensions")
.kind = .warning
.suppress_version = .c23
non_int_bitfield
.msg = "bit-field has non-integer type '{s}'"
.extra = .str
.kind = .@"error"
negative_bitwidth
.msg = "bit-field has negative width ({s})"
.extra = .str
.kind = .@"error"
zero_width_named_field
.msg = "named bit-field has zero width"
.kind = .@"error"
bitfield_too_big
.msg = "width of bit-field exceeds width of its type"
.kind = .@"error"
invalid_utf8
.msg = "source file is not valid UTF-8"
.kind = .@"error"
implicitly_unsigned_literal
.msg = "integer literal is too large to be represented in a signed integer type, interpreting as unsigned"
.opt = W("implicitly-unsigned-literal")
.kind = .warning
invalid_preproc_operator
.msg = "token is not a valid binary operator in a preprocessor subexpression"
.kind = .@"error"
invalid_preproc_expr_start
.msg = "invalid token at start of a preprocessor expression"
.kind = .@"error"
c99_compat
.msg = "using this character in an identifier is incompatible with C99"
.opt = W("c99-compat")
.kind = .off
unexpected_character
.msg = "unexpected character <U+{X:0>4}>"
.extra = .actual_codepoint
.kind = .@"error"
invalid_identifier_start_char
.msg = "character <U+{X:0>4}> not allowed at the start of an identifier"
.extra = .actual_codepoint
.kind = .@"error"
unicode_zero_width
.msg = "identifier contains Unicode character <U+{X:0>4}> that is invisible in some environments"
.opt = W("unicode-homoglyph")
.extra = .actual_codepoint
.kind = .warning
unicode_homoglyph
.msg = "treating Unicode character <U+{X:0>4}> as identifier character rather than as '{u}' symbol"
.extra = .codepoints
.opt = W("unicode-homoglyph")
.kind = .warning
meaningless_asm_qual
.msg = "meaningless '{s}' on assembly outside function"
.extra = .str
.kind = .@"error"
duplicate_asm_qual
.msg = "duplicate asm qualifier '{s}'"
.extra = .str
.kind = .@"error"
invalid_asm_str
.msg = "cannot use {s} string literal in assembly"
.extra = .str
.kind = .@"error"
dollar_in_identifier_extension
.msg = "'$' in identifier"
.opt = W("dollar-in-identifier-extension")
.kind = .off
.pedantic = true
dollars_in_identifiers
.msg = "illegal character '$' in identifier"
.kind = .@"error"
expanded_from_here
.msg = "expanded from here"
.kind = .note
skipping_macro_backtrace
.msg = "(skipping {d} expansions in backtrace; use -fmacro-backtrace-limit=0 to see all)"
.extra = .unsigned
.kind = .note
pragma_operator_string_literal
.msg = "_Pragma requires exactly one string literal token"
.kind = .@"error"
unknown_gcc_pragma
.msg = "pragma GCC expected 'error', 'warning', 'diagnostic', 'poison'"
.opt = W("unknown-pragmas")
.kind = .off
.all = true
unknown_gcc_pragma_directive
.msg = "pragma GCC diagnostic expected 'error', 'warning', 'ignored', 'fatal', 'push', or 'pop'"
.opt = W("unknown-pragmas")
.kind = .warning
.all = true
predefined_top_level
.msg = "predefined identifier is only valid inside function"
.opt = W("predefined-identifier-outside-function")
.kind = .warning
incompatible_va_arg
.msg = "first argument to va_arg, is of type '{s}' and not 'va_list'"
.extra = .str
.kind = .@"error"
too_many_scalar_init_braces
.msg = "too many braces around scalar initializer"
.opt = W("many-braces-around-scalar-init")
.kind = .warning
uninitialized_in_own_init
.msg = "variable '{s}' is uninitialized when used within its own initialization"
.extra = .str
.opt = W("uninitialized")
.kind = .off
.all = true
gnu_statement_expression
.msg = "use of GNU statement expression extension"
.opt = W("gnu-statement-expression")
.kind = .off
.suppress_gnu = true
.pedantic = true
stmt_expr_not_allowed_file_scope
.msg = "statement expression not allowed at file scope"
.kind = .@"error"
gnu_imaginary_constant
.msg = "imaginary constants are a GNU extension"
.opt = W("gnu-imaginary-constant")
.kind = .off
.suppress_gnu = true
.pedantic = true
plain_complex
.msg = "plain '_Complex' requires a type specifier; assuming '_Complex double'"
.kind = .warning
complex_int
.msg = "complex integer types are a GNU extension"
.opt = W("gnu-complex-integer")
.suppress_gnu = true
.kind = .off
qual_on_ret_type
.msg = "'{s}' type qualifier on return type has no effect"
.opt = W("ignored-qualifiers")
.extra = .str
.kind = .off
.all = true
cli_invalid_standard
.msg = "invalid standard '{s}'"
.extra = .str
.kind = .@"error"
cli_invalid_target
.msg = "invalid target '{s}'"
.extra = .str
.kind = .@"error"
cli_invalid_emulate
.msg = "invalid compiler '{s}'"
.extra = .str
.kind = .@"error"
cli_unknown_arg
.msg = "unknown argument '{s}'"
.extra = .str
.kind = .@"error"
cli_error
.msg = "{s}"
.extra = .str
.kind = .@"error"
cli_unused_link_object
.msg = "{s}: linker input file unused because linking not done"
.extra = .str
.kind = .warning
cli_unknown_linker
.msg = "unrecognized linker '{s}'"
.extra = .str
.kind = .@"error"
extra_semi
.msg = "extra ';' outside of a function"
.opt = W("extra-semi")
.kind = .off
.pedantic = true
func_field
.msg = "field declared as a function"
.kind = .@"error"
vla_field
.msg = "variable length array fields extension is not supported"
.kind = .@"error"
field_incomplete_ty
.msg = "field has incomplete type '{s}'"
.extra = .str
.kind = .@"error"
flexible_in_union
.msg = "flexible array member in union is not allowed"
.kind = .@"error"
.suppress_msvc = true
flexible_non_final
.msg = "flexible array member is not at the end of struct"
.kind = .@"error"
flexible_in_empty
.msg = "flexible array member in otherwise empty struct"
.kind = .@"error"
.suppress_msvc = true
duplicate_member
.msg = "duplicate member '{s}'"
.extra = .str
.kind = .@"error"
binary_integer_literal
.msg = "binary integer literals are a GNU extension"
.kind = .off
.opt = W("gnu-binary-literal")
.pedantic = true
gnu_va_macro
.msg = "named variadic macros are a GNU extension"
.opt = W("variadic-macros")
.kind = .off
.pedantic = true
builtin_must_be_called
.msg = "builtin function must be directly called"
.kind = .@"error"
va_start_not_in_func
.msg = "'va_start' cannot be used outside a function"
.kind = .@"error"
va_start_fixed_args
.msg = "'va_start' used in a function with fixed args"
.kind = .@"error"
va_start_not_last_param
.msg = "second argument to 'va_start' is not the last named parameter"
.opt = W("varargs")
.kind = .warning
attribute_not_enough_args
.msg = "'{s}' attribute takes at least {d} argument(s)"
.kind = .@"error"
.extra = .attr_arg_count
attribute_too_many_args
.msg = "'{s}' attribute takes at most {d} argument(s)"
.kind = .@"error"
.extra = .attr_arg_count
attribute_arg_invalid
.msg = "Attribute argument is invalid, expected {s} but got {s}"
.kind = .@"error"
.extra = .attr_arg_type
unknown_attr_enum
.msg = "Unknown `{s}` argument. Possible values are: {s}"
.kind = .@"error"
.extra = .attr_enum
attribute_requires_identifier
.msg = "'{s}' attribute requires an identifier"
.kind = .@"error"
.extra = .str
declspec_not_enabled
.msg = "'__declspec' attributes are not enabled; use '-fdeclspec' or '-fms-extensions' to enable support for __declspec attributes"
.kind = .@"error"
declspec_attr_not_supported
.msg = "__declspec attribute '{s}' is not supported"
.extra = .str
.opt = W("ignored-attributes")
.kind = .warning
deprecated_declarations
.msg = "{s}"
.extra = .str
.opt = W("deprecated-declarations")
.kind = .warning
deprecated_note
.msg = "'{s}' has been explicitly marked deprecated here"
.extra = .str
.opt = W("deprecated-declarations")
.kind = .note
unavailable
.msg = "{s}"
.extra = .str
.kind = .@"error"
unavailable_note
.msg = "'{s}' has been explicitly marked unavailable here"
.extra = .str
.kind = .note
warning_attribute
.msg = "{s}"
.extra = .str
.kind = .warning
.opt = W("attribute-warning")
error_attribute
.msg = "{s}"
.extra = .str
.kind = .@"error"
ignored_record_attr
.msg = "attribute '{s}' is ignored, place it after \"{s}\" to apply attribute to type declaration"
.extra = .ignored_record_attr
.kind = .warning
.opt = W("ignored-attributes")
backslash_newline_escape
.msg = "backslash and newline separated by space"
.kind = .warning
.opt = W("backslash-newline-escape")
array_size_non_int
.msg = "size of array has non-integer type '{s}'"
.extra = .str
.kind = .@"error"
cast_to_smaller_int
.msg = "cast to smaller integer type {s}"
.extra = .str
.kind = .warning
.opt = W("pointer-to-int-cast")
gnu_switch_range
.msg = "use of GNU case range extension"
.opt = W("gnu-case-range")
.kind = .off
.pedantic = true
empty_case_range
.msg = "empty case range specified"
.kind = .warning
non_standard_escape_char
.msg = "use of non-standard escape character '\\{s}'"
.kind = .off
.opt = W("pedantic")
.extra = .invalid_escape
invalid_pp_stringify_escape
.msg = "invalid string literal, ignoring final '\\'"
.kind = .warning
vla
.msg = "variable length array used"
.kind = .off
.opt = W("vla")
int_value_changed
.msg = "implicit conversion from {s}"
.extra = .str
.kind = .warning
.opt = W("constant-conversion")
sign_conversion
.msg = "implicit conversion changes signedness: {s}"
.extra = .str
.kind = .off
.opt = W("sign-conversion")
float_overflow_conversion
.msg = "implicit conversion of non-finite value from {s} is undefined"
.extra = .str
.kind = .off
.opt = W("float-overflow-conversion")
float_out_of_range
.msg = "implicit conversion of out of range value from {s} is undefined"
.extra = .str
.kind = .warning
.opt = W("literal-conversion")
float_zero_conversion
.msg = "implicit conversion from {s}"
.extra = .str
.kind = .off
.opt = W("float-zero-conversion")
float_value_changed
.msg = "implicit conversion from {s}"
.extra = .str
.kind = .warning
.opt = W("float-conversion")
float_to_int
.msg = "implicit conversion turns floating-point number into integer: {s}"
.extra = .str
.kind = .off
.opt = W("literal-conversion")
const_decl_folded
.msg = "expression is not an integer constant expression; folding it to a constant is a GNU extension"
.kind = .off
.opt = W("gnu-folding-constant")
.pedantic = true
const_decl_folded_vla
.msg = "variable length array folded to constant array as an extension"
.kind = .off
.opt = W("gnu-folding-constant")
.pedantic = true
redefinition_of_typedef
.msg = "typedef redefinition with different types ({s})"
.extra = .str
.kind = .@"error"
undefined_macro
.msg = "'{s}' is not defined, evaluates to 0"
.extra = .str
.kind = .off
.opt = W("undef")
fn_macro_undefined
.msg = "function-like macro '{s}' is not defined"
.extra = .str
.kind = .@"error"
preprocessing_directive_only
.msg = "'{s}' must be used within a preprocessing directive"
.extra = .tok_id_expected
.kind = .@"error"
missing_lparen_after_builtin
.msg = "Missing '(' after built-in macro '{s}'"
.extra = .str
.kind = .@"error"
offsetof_ty
.msg = "offsetof requires struct or union type, '{s}' invalid"
.extra = .str
.kind = .@"error"
offsetof_incomplete
.msg = "offsetof of incomplete type '{s}'"
.extra = .str
.kind = .@"error"
offsetof_array
.msg = "offsetof requires array type, '{s}' invalid"
.extra = .str
.kind = .@"error"
pragma_pack_lparen
.msg = "missing '(' after '#pragma pack' - ignoring"
.kind = .warning
.opt = W("ignored-pragmas")
pragma_pack_rparen
.msg = "missing ')' after '#pragma pack' - ignoring"
.kind = .warning
.opt = W("ignored-pragmas")
pragma_pack_unknown_action
.msg = "unknown action for '#pragma pack' - ignoring"
.opt = W("ignored-pragmas")
.kind = .warning
pragma_pack_show
.msg = "value of #pragma pack(show) == {d}"
.extra = .unsigned
.kind = .warning
pragma_pack_int
.msg = "expected #pragma pack parameter to be '1', '2', '4', '8', or '16'"
.opt = W("ignored-pragmas")
.kind = .warning
pragma_pack_int_ident
.msg = "expected integer or identifier in '#pragma pack' - ignored"
.opt = W("ignored-pragmas")
.kind = .warning
pragma_pack_undefined_pop
.msg = "specifying both a name and alignment to 'pop' is undefined"
.kind = .warning
pragma_pack_empty_stack
.msg = "#pragma pack(pop, ...) failed: stack empty"
.opt = W("ignored-pragmas")
.kind = .warning
cond_expr_type
.msg = "used type '{s}' where arithmetic or pointer type is required"
.extra = .str
.kind = .@"error"
too_many_includes
.msg = "#include nested too deeply"
.kind = .@"error"
enumerator_too_small
.msg = "ISO C restricts enumerator values to range of 'int' ({s} is too small)"
.extra = .str
.kind = .off
.opt = W("pedantic")
enumerator_too_large
.msg = "ISO C restricts enumerator values to range of 'int' ({s} is too large)"
.extra = .str
.kind = .off
.opt = W("pedantic")
include_next
.msg = "#include_next is a language extension"
.kind = .off
.pedantic = true
.opt = W("gnu-include-next")
include_next_outside_header
.msg = "#include_next in primary source file; will search from start of include path"
.kind = .warning
.opt = W("include-next-outside-header")
enumerator_overflow
.msg = "overflow in enumeration value"
.kind = .warning
enum_not_representable
.msg = "incremented enumerator value {s} is not representable in the largest integer type"
.kind = .warning
.opt = W("enum-too-large")
.extra = .pow_2_as_string
enum_too_large
.msg = "enumeration values exceed range of largest integer"
.kind = .warning
.opt = W("enum-too-large")
enum_fixed
.msg = "enumeration types with a fixed underlying type are a Clang extension"
.kind = .off
.pedantic = true
.opt = W("fixed-enum-extension")
enum_prev_nonfixed
.msg = "enumeration previously declared with nonfixed underlying type"
.kind = .@"error"
enum_prev_fixed
.msg = "enumeration previously declared with fixed underlying type"
.kind = .@"error"
enum_different_explicit_ty
# str will be like 'new' (was 'old'
.msg = "enumeration redeclared with different underlying type {s})"
.extra = .str
.kind = .@"error"
enum_not_representable_fixed
.msg = "enumerator value is not representable in the underlying type '{s}'"
.extra = .str
.kind = .@"error"
transparent_union_wrong_type
.msg = "'transparent_union' attribute only applies to unions"
.opt = W("ignored-attributes")
.kind = .warning
transparent_union_one_field
.msg = "transparent union definition must contain at least one field; transparent_union attribute ignored"
.opt = W("ignored-attributes")
.kind = .warning
transparent_union_size
.msg = "size of field {s} bits) does not match the size of the first field in transparent union; transparent_union attribute ignored"
.extra = .str
.opt = W("ignored-attributes")
.kind = .warning
transparent_union_size_note
.msg = "size of first field is {d}"
.extra = .unsigned
.kind = .note
designated_init_invalid
.msg = "'designated_init' attribute is only valid on 'struct' type'"
.kind = .@"error"
designated_init_needed
.msg = "positional initialization of field in 'struct' declared with 'designated_init' attribute"
.opt = W("designated-init")
.kind = .warning
ignore_common
.msg = "ignoring attribute 'common' because it conflicts with attribute 'nocommon'"
.opt = W("ignored-attributes")
.kind = .warning
ignore_nocommon
.msg = "ignoring attribute 'nocommon' because it conflicts with attribute 'common'"
.opt = W("ignored-attributes")
.kind = .warning
non_string_ignored
.msg = "'nonstring' attribute ignored on objects of type '{s}'"
.opt = W("ignored-attributes")
.kind = .warning
local_variable_attribute
.msg = "'{s}' attribute only applies to local variables"
.extra = .str
.opt = W("ignored-attributes")
.kind = .warning
ignore_cold
.msg = "ignoring attribute 'cold' because it conflicts with attribute 'hot'"
.opt = W("ignored-attributes")
.kind = .warning
ignore_hot
.msg = "ignoring attribute 'hot' because it conflicts with attribute 'cold'"
.opt = W("ignored-attributes")
.kind = .warning
ignore_noinline
.msg = "ignoring attribute 'noinline' because it conflicts with attribute 'always_inline'"
.opt = W("ignored-attributes")
.kind = .warning
ignore_always_inline
.msg = "ignoring attribute 'always_inline' because it conflicts with attribute 'noinline'"
.opt = W("ignored-attributes")
.kind = .warning
invalid_noreturn
.msg = "function '{s}' declared 'noreturn' should not return"
.extra = .str
.kind = .warning
.opt = W("invalid-noreturn")
nodiscard_unused
.msg = "ignoring return value of '{s}', declared with 'nodiscard' attribute"
.extra = .str
.kind = .warning
.opt = W("unused-result")
warn_unused_result
.msg = "ignoring return value of '{s}', declared with 'warn_unused_result' attribute"
.extra = .str
.kind = .warning
.opt = W("unused-result")
invalid_vec_elem_ty
.msg = "invalid vector element type '{s}'"
.extra = .str
.kind = .@"error"
vec_size_not_multiple
.msg = "vector size not an integral multiple of component size"
.kind = .@"error"
invalid_imag
.msg = "invalid type '{s}' to __imag operator"
.extra = .str
.kind = .@"error"
invalid_real
.msg = "invalid type '{s}' to __real operator"
.extra = .str
.kind = .@"error"
zero_length_array
.msg = "zero size arrays are an extension"
.kind = .off
.pedantic = true
.opt = W("zero-length-array")
old_style_flexible_struct
.msg = "array index {s} is past the end of the array"
.extra = .str
.kind = .off
.pedantic = true
.opt = W("old-style-flexible-struct")
comma_deletion_va_args
.msg = "token pasting of ',' and __VA_ARGS__ is a GNU extension"
.kind = .off
.pedantic = true
.opt = W("gnu-zero-variadic-macro-arguments")
.suppress_gcc = true
main_return_type
.msg = "return type of 'main' is not 'int'"
.kind = .warning
.opt = W("main-return-type")
expansion_to_defined
.msg = "macro expansion producing 'defined' has undefined behavior"
.kind = .off
.pedantic = true
.opt = W("expansion-to-defined")
invalid_int_suffix
.msg = "invalid suffix '{s}' on integer constant"
.extra = .str
.kind = .@"error"
invalid_float_suffix
.msg = "invalid suffix '{s}' on floating constant"
.extra = .str
.kind = .@"error"
invalid_octal_digit
.msg = "invalid digit '{c}' in octal constant"
.extra = .ascii
.kind = .@"error"
invalid_binary_digit
.msg = "invalid digit '{c}' in binary constant"
.extra = .ascii
.kind = .@"error"
exponent_has_no_digits
.msg = "exponent has no digits"
.kind = .@"error"
hex_floating_constant_requires_exponent
.msg = "hexadecimal floating constant requires an exponent"
.kind = .@"error"
sizeof_returns_zero
.msg = "sizeof returns 0"
.kind = .warning
.suppress_gcc = true
.suppress_clang = true
declspec_not_allowed_after_declarator
.msg = "'declspec' attribute not allowed after declarator"
.kind = .@"error"
declarator_name_tok
.msg = "this declarator"
.kind = .note
type_not_supported_on_target
.msg = "{s} is not supported on this target"
.extra = .str
.kind = .@"error"
bit_int
.msg = "'_BitInt' in C17 and earlier is a Clang extension'"
.kind = .off
.pedantic = true
.opt = W("bit-int-extension")
.suppress_version = .c23
unsigned_bit_int_too_small
.msg = "{s}unsigned _BitInt must have a bit size of at least 1"
.extra = .str
.kind = .@"error"
signed_bit_int_too_small
.msg = "{s}signed _BitInt must have a bit size of at least 2"
.extra = .str
.kind = .@"error"
unsigned_bit_int_too_big
.msg = "{s}unsigned _BitInt of bit sizes greater than " ++ std.fmt.comptimePrint("{d}", .{Properties.max_bits}) ++ " not supported"
.extra = .str
.kind = .@"error"
signed_bit_int_too_big
.msg = "{s}signed _BitInt of bit sizes greater than " ++ std.fmt.comptimePrint("{d}", .{Properties.max_bits}) ++ " not supported"
.extra = .str
.kind = .@"error"
keyword_macro
.msg = "keyword is hidden by macro definition"
.kind = .off
.pedantic = true
.opt = W("keyword-macro")
ptr_arithmetic_incomplete
.msg = "arithmetic on a pointer to an incomplete type '{s}'"
.extra = .str
.kind = .@"error"
callconv_not_supported
.msg = "'{s}' calling convention is not supported for this target"
.extra = .str
.opt = W("ignored-attributes")
.kind = .warning
pointer_arith_void
.msg = "invalid application of '{s}' to a void type"
.extra = .str
.kind = .off
.pedantic = true
.opt = W("pointer-arith")
sizeof_array_arg
.msg = "sizeof on array function parameter will return size of {s}"
.extra = .str
.kind = .warning
.opt = W("sizeof-array-argument")
array_address_to_bool
.msg = "address of array '{s}' will always evaluate to 'true'"
.extra = .str
.kind = .warning
.opt = W("pointer-bool-conversion")
string_literal_to_bool
.msg = "implicit conversion turns string literal into bool: {s}"
.extra = .str
.kind = .off
.opt = W("string-conversion")
constant_expression_conversion_not_allowed
.msg = "this conversion is not allowed in a constant expression"
.kind = .note
invalid_object_cast
.msg = "cannot cast an object of type {s}"
.extra = .str
.kind = .@"error"
cli_invalid_fp_eval_method
.msg = "unsupported argument '{s}' to option '-ffp-eval-method='; expected 'source', 'double', or 'extended'"
.extra = .str
.kind = .@"error"
suggest_pointer_for_invalid_fp16
.msg = "{s} cannot have __fp16 type; did you forget * ?"
.extra = .str
.kind = .@"error"
bitint_suffix
.msg = "'_BitInt' suffix for literals is a C23 extension"
.opt = W("c23-extensions")
.kind = .warning
.suppress_version = .c23
auto_type_extension
.msg = "'__auto_type' is a GNU extension"
.opt = W("gnu-auto-type")
.kind = .off
.pedantic = true
auto_type_not_allowed
.msg = "'__auto_type' not allowed in {s}"
.kind = .@"error"
.extra = .str
auto_type_requires_initializer
.msg = "declaration of variable '{s}' with deduced type requires an initializer"
.kind = .@"error"
.extra = .str
auto_type_requires_single_declarator
.msg = "'__auto_type' may only be used with a single declarator"
.kind = .@"error"
auto_type_requires_plain_declarator
.msg = "'__auto_type' requires a plain identifier as declarator"
.kind = .@"error"
invalid_cast_to_auto_type
.msg = "invalid cast to '__auto_type'"
.kind = .@"error"
auto_type_from_bitfield
.msg = "cannot use bit-field as '__auto_type' initializer"
.kind = .@"error"
array_of_auto_type
.msg = "'{s}' declared as array of '__auto_type'"
.kind = .@"error"
.extra = .str
auto_type_with_init_list
.msg = "cannot use '__auto_type' with initializer list"
.kind = .@"error"
missing_semicolon
.msg = "expected ';' at end of declaration list"
.kind = .warning
tentative_definition_incomplete
.msg = "tentative definition has type '{s}' that is never completed"
.kind = .@"error"
.extra = .str
forward_declaration_here
.msg = "forward declaration of '{s}'"
.kind = .note
.extra = .str
gnu_union_cast
.msg = "cast to union type is a GNU extension"
.opt = W("gnu-union-cast")
.kind = .off
.pedantic = true
invalid_union_cast
.msg = "cast to union type from type '{s}' not present in union"
.kind = .@"error"
.extra = .str
cast_to_incomplete_type
.msg = "cast to incomplete type '{s}'"
.kind = .@"error"
.extra = .str
invalid_source_epoch
.msg = "environment variable SOURCE_DATE_EPOCH must expand to a non-negative integer less than or equal to 253402300799"
.kind = .@"error"
fuse_ld_path
.msg = "'-fuse-ld=' taking a path is deprecated; use '--ld-path=' instead"
.kind = .off
.opt = W("fuse-ld-path")
invalid_rtlib
.msg = "invalid runtime library name '{s}'"
.kind = .@"error"
.extra = .str
unsupported_rtlib_gcc
.msg = "unsupported runtime library 'libgcc' for platform '{s}'"
.kind = .@"error"
.extra = .str
invalid_unwindlib
.msg = "invalid unwind library name '{s}'"
.kind = .@"error"
.extra = .str
incompatible_unwindlib
.msg = "--rtlib=libgcc requires --unwindlib=libgcc"
.kind = .@"error"
gnu_asm_disabled
.msg = "GNU-style inline assembly is disabled"
.kind = .@"error"
extension_token_used
.msg = "extension used"
.kind = .off
.pedantic = true
.opt = W("language-extension-token")
complex_component_init
.msg = "complex initialization specifying real and imaginary components is an extension"
.opt = W("complex-component-init")
.kind = .off
.pedantic = true
complex_prefix_postfix_op
.msg = "ISO C does not support '++'/'--' on complex type '{s}'"
.opt = W("pedantic")
.extra = .str
.kind = .off
not_floating_type
.msg = "argument type '{s}' is not a real floating point type"
.extra = .str
.kind = .@"error"
argument_types_differ
.msg = "arguments are of different types ({s})"
.extra = .str
.kind = .@"error"
ms_search_rule
.msg = "#include resolved using non-portable Microsoft search rules as: {s}"
.extra = .str
.opt = W("microsoft-include")
.kind = .warning
ctrl_z_eof
.msg = "treating Ctrl-Z as end-of-file is a Microsoft extension"
.opt = W("microsoft-end-of-file")
.kind = .off
.pedantic = true
illegal_char_encoding_warning
.msg = "illegal character encoding in character literal"
.opt = W("invalid-source-encoding")
.kind = .warning
illegal_char_encoding_error
.msg = "illegal character encoding in character literal"
.kind = .@"error"
ucn_basic_char_error
.msg = "character '{c}' cannot be specified by a universal character name"
.kind = .@"error"
.extra = .ascii
ucn_basic_char_warning
.msg = "specifying character '{c}' with a universal character name is incompatible with C standards before C23"
.kind = .off
.extra = .ascii
.suppress_unless_version = .c23
.opt = W("pre-c23-compat")
ucn_control_char_error
.msg = "universal character name refers to a control character"
.kind = .@"error"
ucn_control_char_warning
.msg = "universal character name referring to a control character is incompatible with C standards before C23"
.kind = .off
.suppress_unless_version = .c23
.opt = W("pre-c23-compat")
c89_ucn_in_literal
.msg = "universal character names are only valid in C99 or later"
.suppress_version = .c99
.kind = .warning
.opt = W("unicode")
four_char_char_literal
.msg = "multi-character character constant"
.opt = W("four-char-constants")
.kind = .off
multi_char_char_literal
.msg = "multi-character character constant"
.kind = .off
missing_hex_escape
.msg = "\\{c} used with no following hex digits"
.kind = .@"error"
.extra = .ascii
unknown_escape_sequence
.msg = "unknown escape sequence '\\{s}'"
.kind = .warning
.opt = W("unknown-escape-sequence")
.extra = .invalid_escape
attribute_requires_string
.msg = "attribute '{s}' requires an ordinary string"
.kind = .@"error"
.extra = .str
unterminated_string_literal_warning
.msg = "missing terminating '\"' character"
.kind = .warning
.opt = W("invalid-pp-token")
unterminated_string_literal_error
.msg = "missing terminating '\"' character"
.kind = .@"error"
empty_char_literal_warning
.msg = "empty character constant"
.kind = .warning
.opt = W("invalid-pp-token")
empty_char_literal_error
.msg = "empty character constant"
.kind = .@"error"
unterminated_char_literal_warning
.msg = "missing terminating ' character"
.kind = .warning
.opt = W("invalid-pp-token")
unterminated_char_literal_error
.msg = "missing terminating ' character"
.kind = .@"error"
unterminated_comment
.msg = "unterminated comment"
.kind = .@"error"
def_no_proto_deprecated
.msg = "a function definition without a prototype is deprecated in all versions of C and is not supported in C23"
.kind = .warning
.opt = W("deprecated-non-prototype")
passing_args_to_kr
.msg = "passing arguments to a function without a prototype is deprecated in all versions of C and is not supported in C23"
.kind = .warning
.opt = W("deprecated-non-prototype")
unknown_type_name
.msg = "unknown type name '{s}'"
.kind = .@"error"
.extra = .str
label_compound_end
.msg = "label at end of compound statement is a C23 extension"
.opt = W("c23-extensions")
.kind = .warning
.suppress_version = .c23
u8_char_lit
.msg = "UTF-8 character literal is a C23 extension"
.opt = W("c23-extensions")
.kind = .warning
.suppress_version = .c23
malformed_embed_param
.msg = "unexpected token in embed parameter"
.kind = .@"error"
malformed_embed_limit
.msg = "the limit parameter expects one non-negative integer as a parameter"
.kind = .@"error"
duplicate_embed_param
.msg = "duplicate embed parameter '{s}'"
.kind = .warning
.extra = .str
.opt = W("duplicate-embed-param")
unsupported_embed_param
.msg = "unsupported embed parameter '{s}' embed parameter"
.kind = .warning
.extra = .str
.opt = W("unsupported-embed-param")
invalid_compound_literal_storage_class
.msg = "compound literal cannot have {s} storage class"
.kind = .@"error"
.extra = .str
va_opt_lparen
.msg = "missing '(' following __VA_OPT__"
.kind = .@"error"
va_opt_rparen
.msg = "unterminated __VA_OPT__ argument list"
.kind = .@"error"
attribute_int_out_of_range
.msg = "attribute value '{s}' out of range"
.kind = .@"error"
.extra = .str
identifier_not_normalized
.msg = "'{s}' is not in NFC"
.kind = .warning
.extra = .normalized
.opt = W("normalized")
c23_auto_plain_declarator
.msg = "'auto' requires a plain identifier declarator"
.kind = .@"error"
c23_auto_single_declarator
.msg = "'auto' can only be used with a single declarator"
.kind = .@"error"
c32_auto_requires_initializer
.msg = "'auto' requires an initializer"
.kind = .@"error"
c23_auto_scalar_init
.msg = "'auto' requires a scalar initializer"
.kind = .@"error"
negative_shift_count
.msg = "shift count is negative"
.opt = W("shift-count-negative")
.kind = .warning
.all = true
too_big_shift_count
.msg = "shift count >= width of type"
.opt = W("shift-count-overflow")
.kind = .warning
.all = true
complex_conj
.msg = "ISO C does not support '~' for complex conjugation of '{s}'"
.opt = W("pedantic")
.extra = .str
.kind = .off
overflow_builtin_requires_int
.msg = "operand argument to overflow builtin must be an integer ('{s}' invalid)"
.extra = .str
.kind = .@"error"
overflow_result_requires_ptr
.msg = "result argument to overflow builtin must be a pointer to a non-const integer ('{s}' invalid)"
.extra = .str
.kind = .@"error"
attribute_todo
.msg = "TODO: implement '{s}' attribute for {s}"
.extra = .attribute_todo
.kind = .@"error"
invalid_type_underlying_enum
.msg = "non-integral type '{s}' is an invalid underlying type"
.extra = .str
.kind = .@"error"
auto_type_self_initialized
.msg = "variable '{s}' declared with deduced type '__auto_type' cannot appear in its own initializer"
.extra = .str
.kind = .@"error"
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/pragmas/gcc.zig | const std = @import("std");
const mem = std.mem;
const Compilation = @import("../Compilation.zig");
const Pragma = @import("../Pragma.zig");
const Diagnostics = @import("../Diagnostics.zig");
const Preprocessor = @import("../Preprocessor.zig");
const Parser = @import("../Parser.zig");
const TokenIndex = @import("../Tree.zig").TokenIndex;
const GCC = @This();
pragma: Pragma = .{
.beforeParse = beforeParse,
.beforePreprocess = beforePreprocess,
.afterParse = afterParse,
.deinit = deinit,
.preprocessorHandler = preprocessorHandler,
.parserHandler = parserHandler,
.preserveTokens = preserveTokens,
},
original_options: Diagnostics.Options = .{},
options_stack: std.ArrayListUnmanaged(Diagnostics.Options) = .{},
const Directive = enum {
warning,
@"error",
diagnostic,
poison,
const Diagnostics = enum {
ignored,
warning,
@"error",
fatal,
push,
pop,
};
};
fn beforePreprocess(pragma: *Pragma, comp: *Compilation) void {
var self: *GCC = @fieldParentPtr("pragma", pragma);
self.original_options = comp.diagnostics.options;
}
fn beforeParse(pragma: *Pragma, comp: *Compilation) void {
var self: *GCC = @fieldParentPtr("pragma", pragma);
comp.diagnostics.options = self.original_options;
self.options_stack.items.len = 0;
}
fn afterParse(pragma: *Pragma, comp: *Compilation) void {
var self: *GCC = @fieldParentPtr("pragma", pragma);
comp.diagnostics.options = self.original_options;
self.options_stack.items.len = 0;
}
pub fn init(allocator: mem.Allocator) !*Pragma {
var gcc = try allocator.create(GCC);
gcc.* = .{};
return &gcc.pragma;
}
fn deinit(pragma: *Pragma, comp: *Compilation) void {
var self: *GCC = @fieldParentPtr("pragma", pragma);
self.options_stack.deinit(comp.gpa);
comp.gpa.destroy(self);
}
fn diagnosticHandler(self: *GCC, pp: *Preprocessor, start_idx: TokenIndex) Pragma.Error!void {
const diagnostic_tok = pp.tokens.get(start_idx);
if (diagnostic_tok.id == .nl) return;
const diagnostic = std.meta.stringToEnum(Directive.Diagnostics, pp.expandedSlice(diagnostic_tok)) orelse
return error.UnknownPragma;
switch (diagnostic) {
.ignored, .warning, .@"error", .fatal => {
const str = Pragma.pasteTokens(pp, start_idx + 1) catch |err| switch (err) {
error.ExpectedStringLiteral => {
return pp.comp.addDiagnostic(.{
.tag = .pragma_requires_string_literal,
.loc = diagnostic_tok.loc,
.extra = .{ .str = "GCC diagnostic" },
}, pp.expansionSlice(start_idx));
},
else => |e| return e,
};
if (!mem.startsWith(u8, str, "-W")) {
const next = pp.tokens.get(start_idx + 1);
return pp.comp.addDiagnostic(.{
.tag = .malformed_warning_check,
.loc = next.loc,
.extra = .{ .str = "GCC diagnostic" },
}, pp.expansionSlice(start_idx + 1));
}
const new_kind: Diagnostics.Kind = switch (diagnostic) {
.ignored => .off,
.warning => .warning,
.@"error" => .@"error",
.fatal => .@"fatal error",
else => unreachable,
};
try pp.comp.diagnostics.set(str[2..], new_kind);
},
.push => try self.options_stack.append(pp.comp.gpa, pp.comp.diagnostics.options),
.pop => pp.comp.diagnostics.options = self.options_stack.popOrNull() orelse self.original_options,
}
}
fn preprocessorHandler(pragma: *Pragma, pp: *Preprocessor, start_idx: TokenIndex) Pragma.Error!void {
var self: *GCC = @fieldParentPtr("pragma", pragma);
const directive_tok = pp.tokens.get(start_idx + 1);
if (directive_tok.id == .nl) return;
const gcc_pragma = std.meta.stringToEnum(Directive, pp.expandedSlice(directive_tok)) orelse
return pp.comp.addDiagnostic(.{
.tag = .unknown_gcc_pragma,
.loc = directive_tok.loc,
}, pp.expansionSlice(start_idx + 1));
switch (gcc_pragma) {
.warning, .@"error" => {
const text = Pragma.pasteTokens(pp, start_idx + 2) catch |err| switch (err) {
error.ExpectedStringLiteral => {
return pp.comp.addDiagnostic(.{
.tag = .pragma_requires_string_literal,
.loc = directive_tok.loc,
.extra = .{ .str = @tagName(gcc_pragma) },
}, pp.expansionSlice(start_idx + 1));
},
else => |e| return e,
};
const extra = Diagnostics.Message.Extra{ .str = try pp.comp.diagnostics.arena.allocator().dupe(u8, text) };
const diagnostic_tag: Diagnostics.Tag = if (gcc_pragma == .warning) .pragma_warning_message else .pragma_error_message;
return pp.comp.addDiagnostic(
.{ .tag = diagnostic_tag, .loc = directive_tok.loc, .extra = extra },
pp.expansionSlice(start_idx + 1),
);
},
.diagnostic => return self.diagnosticHandler(pp, start_idx + 2) catch |err| switch (err) {
error.UnknownPragma => {
const tok = pp.tokens.get(start_idx + 2);
return pp.comp.addDiagnostic(.{
.tag = .unknown_gcc_pragma_directive,
.loc = tok.loc,
}, pp.expansionSlice(start_idx + 2));
},
else => |e| return e,
},
.poison => {
var i: u32 = 2;
while (true) : (i += 1) {
const tok = pp.tokens.get(start_idx + i);
if (tok.id == .nl) break;
if (!tok.id.isMacroIdentifier()) {
return pp.comp.addDiagnostic(.{
.tag = .pragma_poison_identifier,
.loc = tok.loc,
}, pp.expansionSlice(start_idx + i));
}
const str = pp.expandedSlice(tok);
if (pp.defines.get(str) != null) {
try pp.comp.addDiagnostic(.{
.tag = .pragma_poison_macro,
.loc = tok.loc,
}, pp.expansionSlice(start_idx + i));
}
try pp.poisoned_identifiers.put(str, {});
}
return;
},
}
}
fn parserHandler(pragma: *Pragma, p: *Parser, start_idx: TokenIndex) Compilation.Error!void {
var self: *GCC = @fieldParentPtr("pragma", pragma);
const directive_tok = p.pp.tokens.get(start_idx + 1);
if (directive_tok.id == .nl) return;
const name = p.pp.expandedSlice(directive_tok);
if (mem.eql(u8, name, "diagnostic")) {
return self.diagnosticHandler(p.pp, start_idx + 2) catch |err| switch (err) {
error.UnknownPragma => {}, // handled during preprocessing
error.StopPreprocessing => unreachable, // Only used by #pragma once
else => |e| return e,
};
}
}
fn preserveTokens(_: *Pragma, pp: *Preprocessor, start_idx: TokenIndex) bool {
const next = pp.tokens.get(start_idx + 1);
if (next.id != .nl) {
const name = pp.expandedSlice(next);
if (mem.eql(u8, name, "poison")) {
return false;
}
}
return true;
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/pragmas/pack.zig | const std = @import("std");
const mem = std.mem;
const Compilation = @import("../Compilation.zig");
const Pragma = @import("../Pragma.zig");
const Diagnostics = @import("../Diagnostics.zig");
const Preprocessor = @import("../Preprocessor.zig");
const Parser = @import("../Parser.zig");
const Tree = @import("../Tree.zig");
const TokenIndex = Tree.TokenIndex;
const Pack = @This();
pragma: Pragma = .{
.deinit = deinit,
.parserHandler = parserHandler,
.preserveTokens = preserveTokens,
},
stack: std.ArrayListUnmanaged(struct { label: []const u8, val: u8 }) = .{},
pub fn init(allocator: mem.Allocator) !*Pragma {
var pack = try allocator.create(Pack);
pack.* = .{};
return &pack.pragma;
}
fn deinit(pragma: *Pragma, comp: *Compilation) void {
var self: *Pack = @fieldParentPtr("pragma", pragma);
self.stack.deinit(comp.gpa);
comp.gpa.destroy(self);
}
fn parserHandler(pragma: *Pragma, p: *Parser, start_idx: TokenIndex) Compilation.Error!void {
var pack: *Pack = @fieldParentPtr("pragma", pragma);
var idx = start_idx + 1;
const l_paren = p.pp.tokens.get(idx);
if (l_paren.id != .l_paren) {
return p.comp.addDiagnostic(.{
.tag = .pragma_pack_lparen,
.loc = l_paren.loc,
}, p.pp.expansionSlice(idx));
}
idx += 1;
// TODO -fapple-pragma-pack -fxl-pragma-pack
const apple_or_xl = false;
const tok_ids = p.pp.tokens.items(.id);
const arg = idx;
switch (tok_ids[arg]) {
.identifier => {
idx += 1;
const Action = enum {
show,
push,
pop,
};
const action = std.meta.stringToEnum(Action, p.tokSlice(arg)) orelse {
return p.errTok(.pragma_pack_unknown_action, arg);
};
switch (action) {
.show => {
try p.errExtra(.pragma_pack_show, arg, .{ .unsigned = p.pragma_pack orelse 8 });
},
.push, .pop => {
var new_val: ?u8 = null;
var label: ?[]const u8 = null;
if (tok_ids[idx] == .comma) {
idx += 1;
const next = idx;
idx += 1;
switch (tok_ids[next]) {
.pp_num => new_val = (try packInt(p, next)) orelse return,
.identifier => {
label = p.tokSlice(next);
if (tok_ids[idx] == .comma) {
idx += 1;
const int = idx;
idx += 1;
if (tok_ids[int] != .pp_num) return p.errTok(.pragma_pack_int_ident, int);
new_val = (try packInt(p, int)) orelse return;
}
},
else => return p.errTok(.pragma_pack_int_ident, next),
}
}
if (action == .push) {
try pack.stack.append(p.gpa, .{ .label = label orelse "", .val = p.pragma_pack orelse 8 });
} else {
pack.pop(p, label);
if (new_val != null) {
try p.errTok(.pragma_pack_undefined_pop, arg);
} else if (pack.stack.items.len == 0) {
try p.errTok(.pragma_pack_empty_stack, arg);
}
}
if (new_val) |some| {
p.pragma_pack = some;
}
},
}
},
.r_paren => if (apple_or_xl) {
pack.pop(p, null);
} else {
p.pragma_pack = null;
},
.pp_num => {
const new_val = (try packInt(p, arg)) orelse return;
idx += 1;
if (apple_or_xl) {
try pack.stack.append(p.gpa, .{ .label = "", .val = p.pragma_pack });
}
p.pragma_pack = new_val;
},
else => {},
}
if (tok_ids[idx] != .r_paren) {
return p.errTok(.pragma_pack_rparen, idx);
}
}
fn packInt(p: *Parser, tok_i: TokenIndex) Compilation.Error!?u8 {
const res = p.parseNumberToken(tok_i) catch |err| switch (err) {
error.ParsingFailed => {
try p.errTok(.pragma_pack_int, tok_i);
return null;
},
else => |e| return e,
};
const int = res.val.toInt(u64, p.comp) orelse 99;
switch (int) {
1, 2, 4, 8, 16 => return @intCast(int),
else => {
try p.errTok(.pragma_pack_int, tok_i);
return null;
},
}
}
fn pop(pack: *Pack, p: *Parser, maybe_label: ?[]const u8) void {
if (maybe_label) |label| {
var i = pack.stack.items.len;
while (i > 0) {
i -= 1;
if (std.mem.eql(u8, pack.stack.items[i].label, label)) {
const prev = pack.stack.orderedRemove(i);
p.pragma_pack = prev.val;
return;
}
}
} else {
const prev = pack.stack.popOrNull() orelse {
p.pragma_pack = 2;
return;
};
p.pragma_pack = prev.val;
}
}
fn preserveTokens(_: *Pragma, pp: *Preprocessor, start_idx: TokenIndex) bool {
_ = pp;
_ = start_idx;
return true;
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/pragmas/once.zig | const std = @import("std");
const mem = std.mem;
const Compilation = @import("../Compilation.zig");
const Pragma = @import("../Pragma.zig");
const Diagnostics = @import("../Diagnostics.zig");
const Preprocessor = @import("../Preprocessor.zig");
const Parser = @import("../Parser.zig");
const TokenIndex = @import("../Tree.zig").TokenIndex;
const Source = @import("../Source.zig");
const Once = @This();
pragma: Pragma = .{
.afterParse = afterParse,
.deinit = deinit,
.preprocessorHandler = preprocessorHandler,
},
pragma_once: std.AutoHashMap(Source.Id, void),
preprocess_count: u32 = 0,
pub fn init(allocator: mem.Allocator) !*Pragma {
var once = try allocator.create(Once);
once.* = .{
.pragma_once = std.AutoHashMap(Source.Id, void).init(allocator),
};
return &once.pragma;
}
fn afterParse(pragma: *Pragma, _: *Compilation) void {
var self: *Once = @fieldParentPtr("pragma", pragma);
self.pragma_once.clearRetainingCapacity();
}
fn deinit(pragma: *Pragma, comp: *Compilation) void {
var self: *Once = @fieldParentPtr("pragma", pragma);
self.pragma_once.deinit();
comp.gpa.destroy(self);
}
fn preprocessorHandler(pragma: *Pragma, pp: *Preprocessor, start_idx: TokenIndex) Pragma.Error!void {
var self: *Once = @fieldParentPtr("pragma", pragma);
const name_tok = pp.tokens.get(start_idx);
const next = pp.tokens.get(start_idx + 1);
if (next.id != .nl) {
try pp.comp.addDiagnostic(.{
.tag = .extra_tokens_directive_end,
.loc = name_tok.loc,
}, pp.expansionSlice(start_idx + 1));
}
const seen = self.preprocess_count == pp.preprocess_count;
const prev = try self.pragma_once.fetchPut(name_tok.loc.id, {});
if (prev != null and !seen) {
return error.StopPreprocessing;
}
self.preprocess_count = pp.preprocess_count;
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/pragmas/message.zig | const std = @import("std");
const mem = std.mem;
const Compilation = @import("../Compilation.zig");
const Pragma = @import("../Pragma.zig");
const Diagnostics = @import("../Diagnostics.zig");
const Preprocessor = @import("../Preprocessor.zig");
const Parser = @import("../Parser.zig");
const TokenIndex = @import("../Tree.zig").TokenIndex;
const Source = @import("../Source.zig");
const Message = @This();
pragma: Pragma = .{
.deinit = deinit,
.preprocessorHandler = preprocessorHandler,
},
pub fn init(allocator: mem.Allocator) !*Pragma {
var once = try allocator.create(Message);
once.* = .{};
return &once.pragma;
}
fn deinit(pragma: *Pragma, comp: *Compilation) void {
const self: *Message = @fieldParentPtr("pragma", pragma);
comp.gpa.destroy(self);
}
fn preprocessorHandler(_: *Pragma, pp: *Preprocessor, start_idx: TokenIndex) Pragma.Error!void {
const message_tok = pp.tokens.get(start_idx);
const message_expansion_locs = pp.expansionSlice(start_idx);
const str = Pragma.pasteTokens(pp, start_idx + 1) catch |err| switch (err) {
error.ExpectedStringLiteral => {
return pp.comp.addDiagnostic(.{
.tag = .pragma_requires_string_literal,
.loc = message_tok.loc,
.extra = .{ .str = "message" },
}, message_expansion_locs);
},
else => |e| return e,
};
const loc = if (message_expansion_locs.len != 0)
message_expansion_locs[message_expansion_locs.len - 1]
else
message_tok.loc;
const extra = Diagnostics.Message.Extra{ .str = try pp.comp.diagnostics.arena.allocator().dupe(u8, str) };
return pp.comp.addDiagnostic(.{ .tag = .pragma_message, .loc = loc, .extra = extra }, &.{});
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/Attribute/names.def | # multiple
deprecated
.tag = .deprecated
.c23 = true
.gnu = true
.declspec = true
fallthrough
.tag = .fallthrough
.c23 = true
.gnu = true
noreturn
.tag = .@"noreturn"
.c23 = true
.gnu = true
.declspec = true
no_sanitize_address
.tag = .no_sanitize_address
.gnu = true
.declspec = true
noinline
.tag = .@"noinline"
.gnu = true
.declspec = true
# c23 only
nodiscard
.tag = .nodiscard
.c23 = true
reproducible
.tag = .reproducible
.c23 = true
unsequenced
.tag = .unsequenced
.c23 = true
maybe_unused
.tag = .unused
.c23 = true
# gnu only
access
.tag = .access
.gnu = true
alias
.tag = .alias
.gnu = true
aligned
.tag = .aligned
.gnu = true
alloc_align
.tag = .alloc_align
.gnu = true
alloc_size
.tag = .alloc_size
.gnu = true
always_inline
.tag = .always_inline
.gnu = true
artificial
.tag = .artificial
.gnu = true
assume_aligned
.tag = .assume_aligned
.gnu = true
cleanup
.tag = .cleanup
.gnu = true
cold
.tag = .cold
.gnu = true
common
.tag = .common
.gnu = true
const
.tag = .@"const"
.gnu = true
constructor
.tag = .constructor
.gnu = true
copy
.tag = .copy
.gnu = true
designated_init
.tag = .designated_init
.gnu = true
destructor
.tag = .destructor
.gnu = true
error
.tag = .@"error"
.gnu = true
externally_visible
.tag = .externally_visible
.gnu = true
flatten
.tag = .flatten
.gnu = true
format
.tag = .format
.gnu = true
format_arg
.tag = .format_arg
.gnu = true
gnu_inline
.tag = .gnu_inline
.gnu = true
hot
.tag = .hot
.gnu = true
ifunc
.tag = .ifunc
.gnu = true
interrupt
.tag = .interrupt
.gnu = true
interrupt_handler
.tag = .interrupt_handler
.gnu = true
leaf
.tag = .leaf
.gnu = true
malloc
.tag = .malloc
.gnu = true
may_alias
.tag = .may_alias
.gnu = true
mode
.tag = .mode
.gnu = true
no_address_safety_analysis
.tag = .no_address_safety_analysis
.gnu = true
no_icf
.tag = .no_icf
.gnu = true
no_instrument_function
.tag = .no_instrument_function
.gnu = true
no_profile_instrument_function
.tag = .no_profile_instrument_function
.gnu = true
no_reorder
.tag = .no_reorder
.gnu = true
no_sanitize
.tag = .no_sanitize
.gnu = true
no_sanitize_coverage
.tag = .no_sanitize_coverage
.gnu = true
no_sanitize_thread
.tag = .no_sanitize_thread
.gnu = true
no_sanitize_undefined
.tag = .no_sanitize_undefined
.gnu = true
no_split_stack
.tag = .no_split_stack
.gnu = true
no_stack_limit
.tag = .no_stack_limit
.gnu = true
no_stack_protector
.tag = .no_stack_protector
.gnu = true
noclone
.tag = .noclone
.gnu = true
nocommon
.tag = .nocommon
.gnu = true
noinit
.tag = .noinit
.gnu = true
noipa
.tag = .noipa
.gnu = true
# nonnull
# .tag = .nonnull
# .gnu = true
nonstring
.tag = .nonstring
.gnu = true
noplt
.tag = .noplt
.gnu = true
# optimize
# .tag = .optimize
# .gnu = true
packed
.tag = .@"packed"
.gnu = true
patchable_function_entry
.tag = .patchable_function_entry
.gnu = true
persistent
.tag = .persistent
.gnu = true
pure
.tag = .pure
.gnu = true
retain
.tag = .retain
.gnu = true
returns_nonnull
.tag = .returns_nonnull
.gnu = true
returns_twice
.tag = .returns_twice
.gnu = true
scalar_storage_order
.tag = .scalar_storage_order
.gnu = true
section
.tag = .section
.gnu = true
sentinel
.tag = .sentinel
.gnu = true
simd
.tag = .simd
.gnu = true
stack_protect
.tag = .stack_protect
.gnu = true
symver
.tag = .symver
.gnu = true
target
.tag = .target
.gnu = true
target_clones
.tag = .target_clones
.gnu = true
tls_model
.tag = .tls_model
.gnu = true
transparent_union
.tag = .transparent_union
.gnu = true
unavailable
.tag = .unavailable
.gnu = true
uninitialized
.tag = .uninitialized
.gnu = true
unused
.tag = .unused
.gnu = true
used
.tag = .used
.gnu = true
vector_size
.tag = .vector_size
.gnu = true
visibility
.tag = .visibility
.gnu = true
warn_if_not_aligned
.tag = .warn_if_not_aligned
.gnu = true
warn_unused_result
.tag = .warn_unused_result
.gnu = true
warning
.tag = .warning
.gnu = true
weak
.tag = .weak
.gnu = true
weakref
.tag = .weakref
.gnu = true
zero_call_used_regs
.tag = .zero_call_used_regs
.gnu = true
# declspec only
align
.tag = .aligned
.declspec = true
allocate
.tag = .allocate
.declspec = true
allocator
.tag = .allocator
.declspec = true
appdomain
.tag = .appdomain
.declspec = true
code_seg
.tag = .code_seg
.declspec = true
dllexport
.tag = .dllexport
.declspec = true
dllimport
.tag = .dllimport
.declspec = true
jitintrinsic
.tag = .jitintrinsic
.declspec = true
naked
.tag = .naked
.declspec = true
noalias
.tag = .@"noalias"
.declspec = true
process
.tag = .process
.declspec = true
restrict
.tag = .restrict
.declspec = true
safebuffers
.tag = .safebuffers
.declspec = true
selectany
.tag = .selectany
.declspec = true
spectre
.tag = .spectre
.declspec = true
thread
.tag = .thread
.declspec = true
uuid
.tag = .uuid
.declspec = true
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/toolchains/Linux.zig | const std = @import("std");
const mem = std.mem;
const Compilation = @import("../Compilation.zig");
const GCCDetector = @import("../Driver/GCCDetector.zig");
const Toolchain = @import("../Toolchain.zig");
const Driver = @import("../Driver.zig");
const Distro = @import("../Driver/Distro.zig");
const target_util = @import("../target.zig");
const system_defaults = @import("system_defaults");
const Linux = @This();
distro: Distro.Tag = .unknown,
extra_opts: std.ArrayListUnmanaged([]const u8) = .{},
gcc_detector: GCCDetector = .{},
pub fn discover(self: *Linux, tc: *Toolchain) !void {
self.distro = Distro.detect(tc.getTarget(), tc.filesystem);
try self.gcc_detector.discover(tc);
tc.selected_multilib = self.gcc_detector.selected;
try self.gcc_detector.appendToolPath(tc);
try self.buildExtraOpts(tc);
try self.findPaths(tc);
}
fn buildExtraOpts(self: *Linux, tc: *const Toolchain) !void {
const gpa = tc.driver.comp.gpa;
const target = tc.getTarget();
const is_android = target.isAndroid();
if (self.distro.isAlpine() or is_android) {
try self.extra_opts.ensureUnusedCapacity(gpa, 2);
self.extra_opts.appendAssumeCapacity("-z");
self.extra_opts.appendAssumeCapacity("now");
}
if (self.distro.isOpenSUSE() or self.distro.isUbuntu() or self.distro.isAlpine() or is_android) {
try self.extra_opts.ensureUnusedCapacity(gpa, 2);
self.extra_opts.appendAssumeCapacity("-z");
self.extra_opts.appendAssumeCapacity("relro");
}
if (target.cpu.arch.isARM() or target.cpu.arch.isAARCH64() or is_android) {
try self.extra_opts.ensureUnusedCapacity(gpa, 2);
self.extra_opts.appendAssumeCapacity("-z");
self.extra_opts.appendAssumeCapacity("max-page-size=4096");
}
if (target.cpu.arch == .arm or target.cpu.arch == .thumb) {
try self.extra_opts.append(gpa, "-X");
}
if (!target.cpu.arch.isMIPS() and target.cpu.arch != .hexagon) {
const hash_style = if (is_android) .both else self.distro.getHashStyle();
try self.extra_opts.append(gpa, switch (hash_style) {
inline else => |tag| "--hash-style=" ++ @tagName(tag),
});
}
if (system_defaults.enable_linker_build_id) {
try self.extra_opts.append(gpa, "--build-id");
}
}
fn addMultiLibPaths(self: *Linux, tc: *Toolchain, sysroot: []const u8, os_lib_dir: []const u8) !void {
if (!self.gcc_detector.is_valid) return;
const gcc_triple = self.gcc_detector.gcc_triple;
const lib_path = self.gcc_detector.parent_lib_path;
// Add lib/gcc/$triple/$version, with an optional /multilib suffix.
try tc.addPathIfExists(&.{ self.gcc_detector.install_path, tc.selected_multilib.gcc_suffix }, .file);
// Add lib/gcc/$triple/$libdir
// For GCC built with --enable-version-specific-runtime-libs.
try tc.addPathIfExists(&.{ self.gcc_detector.install_path, "..", os_lib_dir }, .file);
try tc.addPathIfExists(&.{ lib_path, "..", gcc_triple, "lib", "..", os_lib_dir, tc.selected_multilib.os_suffix }, .file);
// If the GCC installation we found is inside of the sysroot, we want to
// prefer libraries installed in the parent prefix of the GCC installation.
// It is important to *not* use these paths when the GCC installation is
// outside of the system root as that can pick up unintended libraries.
// This usually happens when there is an external cross compiler on the
// host system, and a more minimal sysroot available that is the target of
// the cross. Note that GCC does include some of these directories in some
// configurations but this seems somewhere between questionable and simply
// a bug.
if (mem.startsWith(u8, lib_path, sysroot)) {
try tc.addPathIfExists(&.{ lib_path, "..", os_lib_dir }, .file);
}
}
fn addMultiArchPaths(self: *Linux, tc: *Toolchain) !void {
if (!self.gcc_detector.is_valid) return;
const lib_path = self.gcc_detector.parent_lib_path;
const gcc_triple = self.gcc_detector.gcc_triple;
const multilib = self.gcc_detector.selected;
try tc.addPathIfExists(&.{ lib_path, "..", gcc_triple, "lib", multilib.os_suffix }, .file);
}
/// TODO: Very incomplete
fn findPaths(self: *Linux, tc: *Toolchain) !void {
const target = tc.getTarget();
const sysroot = tc.getSysroot();
var output: [64]u8 = undefined;
const os_lib_dir = getOSLibDir(target);
const multiarch_triple = getMultiarchTriple(target) orelse target_util.toLLVMTriple(target, &output);
try self.addMultiLibPaths(tc, sysroot, os_lib_dir);
try tc.addPathIfExists(&.{ sysroot, "/lib", multiarch_triple }, .file);
try tc.addPathIfExists(&.{ sysroot, "/lib", "..", os_lib_dir }, .file);
if (target.isAndroid()) {
// TODO
}
try tc.addPathIfExists(&.{ sysroot, "/usr", "lib", multiarch_triple }, .file);
try tc.addPathIfExists(&.{ sysroot, "/usr", "lib", "..", os_lib_dir }, .file);
try self.addMultiArchPaths(tc);
try tc.addPathIfExists(&.{ sysroot, "/lib" }, .file);
try tc.addPathIfExists(&.{ sysroot, "/usr", "lib" }, .file);
}
pub fn deinit(self: *Linux, allocator: std.mem.Allocator) void {
self.extra_opts.deinit(allocator);
}
fn isPIEDefault(self: *const Linux) bool {
_ = self;
return false;
}
fn getPIE(self: *const Linux, d: *const Driver) bool {
if (d.shared or d.static or d.relocatable or d.static_pie) {
return false;
}
return d.pie orelse self.isPIEDefault();
}
fn getStaticPIE(self: *const Linux, d: *Driver) !bool {
_ = self;
if (d.static_pie and d.pie != null) {
try d.err("cannot specify 'nopie' along with 'static-pie'");
}
return d.static_pie;
}
fn getStatic(self: *const Linux, d: *const Driver) bool {
_ = self;
return d.static and !d.static_pie;
}
pub fn getDefaultLinker(self: *const Linux, target: std.Target) []const u8 {
_ = self;
if (target.isAndroid()) {
return "ld.lld";
}
return "ld";
}
pub fn buildLinkerArgs(self: *const Linux, tc: *const Toolchain, argv: *std.ArrayList([]const u8)) Compilation.Error!void {
const d = tc.driver;
const target = tc.getTarget();
const is_pie = self.getPIE(d);
const is_static_pie = try self.getStaticPIE(d);
const is_static = self.getStatic(d);
const is_android = target.isAndroid();
const is_iamcu = target.os.tag == .elfiamcu;
const is_ve = target.cpu.arch == .ve;
const has_crt_begin_end_files = target.abi != .none; // TODO: clang checks for MIPS vendor
if (is_pie) {
try argv.append("-pie");
}
if (is_static_pie) {
try argv.appendSlice(&.{ "-static", "-pie", "--no-dynamic-linker", "-z", "text" });
}
if (d.rdynamic) {
try argv.append("-export-dynamic");
}
if (d.strip) {
try argv.append("-s");
}
try argv.appendSlice(self.extra_opts.items);
try argv.append("--eh-frame-hdr");
// Todo: Driver should parse `-EL`/`-EB` for arm to set endianness for arm targets
if (target_util.ldEmulationOption(d.comp.target, null)) |emulation| {
try argv.appendSlice(&.{ "-m", emulation });
} else {
try d.err("Unknown target triple");
return;
}
if (d.comp.target.cpu.arch.isRISCV()) {
try argv.append("-X");
}
if (d.shared) {
try argv.append("-shared");
}
if (is_static) {
try argv.append("-static");
} else {
if (d.rdynamic) {
try argv.append("-export-dynamic");
}
if (!d.shared and !is_static_pie and !d.relocatable) {
const dynamic_linker = d.comp.target.standardDynamicLinkerPath();
// todo: check for --dyld-prefix
if (dynamic_linker.get()) |path| {
try argv.appendSlice(&.{ "-dynamic-linker", try tc.arena.dupe(u8, path) });
} else {
try d.err("Could not find dynamic linker path");
}
}
}
try argv.appendSlice(&.{ "-o", d.output_name orelse "a.out" });
if (!d.nostdlib and !d.nostartfiles and !d.relocatable) {
if (!is_android and !is_iamcu) {
if (!d.shared) {
const crt1 = if (is_pie)
"Scrt1.o"
else if (is_static_pie)
"rcrt1.o"
else
"crt1.o";
try argv.append(try tc.getFilePath(crt1));
}
try argv.append(try tc.getFilePath("crti.o"));
}
if (is_ve) {
try argv.appendSlice(&.{ "-z", "max-page-size=0x4000000" });
}
if (is_iamcu) {
try argv.append(try tc.getFilePath("crt0.o"));
} else if (has_crt_begin_end_files) {
var path: []const u8 = "";
if (tc.getRuntimeLibKind() == .compiler_rt and !is_android) {
const crt_begin = try tc.getCompilerRt("crtbegin", .object);
if (tc.filesystem.exists(crt_begin)) {
path = crt_begin;
}
}
if (path.len == 0) {
const crt_begin = if (tc.driver.shared)
if (is_android) "crtbegin_so.o" else "crtbeginS.o"
else if (is_static)
if (is_android) "crtbegin_static.o" else "crtbeginT.o"
else if (is_pie or is_static_pie)
if (is_android) "crtbegin_dynamic.o" else "crtbeginS.o"
else if (is_android) "crtbegin_dynamic.o" else "crtbegin.o";
path = try tc.getFilePath(crt_begin);
}
try argv.append(path);
}
}
// TODO add -L opts
// TODO add -u opts
try tc.addFilePathLibArgs(argv);
// TODO handle LTO
try argv.appendSlice(d.link_objects.items);
if (!d.nostdlib and !d.relocatable) {
if (!d.nodefaultlibs) {
if (is_static or is_static_pie) {
try argv.append("--start-group");
}
try tc.addRuntimeLibs(argv);
// TODO: add pthread if needed
if (!d.nolibc) {
try argv.append("-lc");
}
if (is_iamcu) {
try argv.append("-lgloss");
}
if (is_static or is_static_pie) {
try argv.append("--end-group");
} else {
try tc.addRuntimeLibs(argv);
}
if (is_iamcu) {
try argv.appendSlice(&.{ "--as-needed", "-lsoftfp", "--no-as-needed" });
}
}
if (!d.nostartfiles and !is_iamcu) {
if (has_crt_begin_end_files) {
var path: []const u8 = "";
if (tc.getRuntimeLibKind() == .compiler_rt and !is_android) {
const crt_end = try tc.getCompilerRt("crtend", .object);
if (tc.filesystem.exists(crt_end)) {
path = crt_end;
}
}
if (path.len == 0) {
const crt_end = if (d.shared)
if (is_android) "crtend_so.o" else "crtendS.o"
else if (is_pie or is_static_pie)
if (is_android) "crtend_android.o" else "crtendS.o"
else if (is_android) "crtend_android.o" else "crtend.o";
path = try tc.getFilePath(crt_end);
}
try argv.append(path);
}
if (!is_android) {
try argv.append(try tc.getFilePath("crtn.o"));
}
}
}
// TODO add -T args
}
fn getMultiarchTriple(target: std.Target) ?[]const u8 {
const is_android = target.isAndroid();
const is_mips_r6 = std.Target.mips.featureSetHas(target.cpu.features, .mips32r6);
return switch (target.cpu.arch) {
.arm, .thumb => if (is_android) "arm-linux-androideabi" else if (target.abi == .gnueabihf) "arm-linux-gnueabihf" else "arm-linux-gnueabi",
.armeb, .thumbeb => if (target.abi == .gnueabihf) "armeb-linux-gnueabihf" else "armeb-linux-gnueabi",
.aarch64 => if (is_android) "aarch64-linux-android" else "aarch64-linux-gnu",
.aarch64_be => "aarch64_be-linux-gnu",
.x86 => if (is_android) "i686-linux-android" else "i386-linux-gnu",
.x86_64 => if (is_android) "x86_64-linux-android" else if (target.abi == .gnux32) "x86_64-linux-gnux32" else "x86_64-linux-gnu",
.m68k => "m68k-linux-gnu",
.mips => if (is_mips_r6) "mipsisa32r6-linux-gnu" else "mips-linux-gnu",
.mipsel => if (is_android) "mipsel-linux-android" else if (is_mips_r6) "mipsisa32r6el-linux-gnu" else "mipsel-linux-gnu",
.powerpcle => "powerpcle-linux-gnu",
.powerpc64 => "powerpc64-linux-gnu",
.powerpc64le => "powerpc64le-linux-gnu",
.riscv64 => "riscv64-linux-gnu",
.sparc => "sparc-linux-gnu",
.sparc64 => "sparc64-linux-gnu",
.s390x => "s390x-linux-gnu",
// TODO: expand this
else => null,
};
}
fn getOSLibDir(target: std.Target) []const u8 {
switch (target.cpu.arch) {
.x86,
.powerpc,
.powerpcle,
.sparc,
=> return "lib32",
else => {},
}
if (target.cpu.arch == .x86_64 and (target.abi == .gnux32 or target.abi == .muslx32)) {
return "libx32";
}
if (target.cpu.arch == .riscv32) {
return "lib32";
}
if (target.ptrBitWidth() == 32) {
return "lib";
}
return "lib64";
}
pub fn defineSystemIncludes(self: *const Linux, tc: *const Toolchain) !void {
if (tc.driver.nostdinc) return;
const comp = tc.driver.comp;
const target = tc.getTarget();
// musl prefers /usr/include before builtin includes, so musl targets will add builtins
// at the end of this function (unless disabled with nostdlibinc)
if (!tc.driver.nobuiltininc and (!target.isMusl() or tc.driver.nostdlibinc)) {
try comp.addBuiltinIncludeDir(tc.driver.aro_name);
}
if (tc.driver.nostdlibinc) return;
const sysroot = tc.getSysroot();
const local_include = try std.fmt.allocPrint(comp.gpa, "{s}{s}", .{ sysroot, "/usr/local/include" });
defer comp.gpa.free(local_include);
try comp.addSystemIncludeDir(local_include);
if (self.gcc_detector.is_valid) {
const gcc_include_path = try std.fs.path.join(comp.gpa, &.{ self.gcc_detector.parent_lib_path, "..", self.gcc_detector.gcc_triple, "include" });
defer comp.gpa.free(gcc_include_path);
try comp.addSystemIncludeDir(gcc_include_path);
}
if (getMultiarchTriple(target)) |triple| {
const joined = try std.fs.path.join(comp.gpa, &.{ sysroot, "usr", "include", triple });
defer comp.gpa.free(joined);
if (tc.filesystem.exists(joined)) {
try comp.addSystemIncludeDir(joined);
}
}
if (target.os.tag == .rtems) return;
try comp.addSystemIncludeDir("/include");
try comp.addSystemIncludeDir("/usr/include");
std.debug.assert(!tc.driver.nostdlibinc);
if (!tc.driver.nobuiltininc and target.isMusl()) {
try comp.addBuiltinIncludeDir(tc.driver.aro_name);
}
}
test Linux {
if (@import("builtin").os.tag == .windows) return error.SkipZigTest;
var arena_instance = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_instance.deinit();
const arena = arena_instance.allocator();
var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
defer comp.deinit();
comp.environment = .{
.path = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
};
defer comp.environment = .{};
const raw_triple = "x86_64-linux-gnu";
const target_query = try std.Target.Query.parse(.{ .arch_os_abi = raw_triple });
comp.target = try std.zig.system.resolveTargetQuery(target_query);
comp.langopts.setEmulatedCompiler(.gcc);
var driver: Driver = .{ .comp = &comp };
defer driver.deinit();
driver.raw_target_triple = raw_triple;
const link_obj = try driver.comp.gpa.dupe(u8, "/tmp/foo.o");
try driver.link_objects.append(driver.comp.gpa, link_obj);
driver.temp_file_count += 1;
var toolchain: Toolchain = .{ .driver = &driver, .arena = arena, .filesystem = .{ .fake = &.{
.{ .path = "/tmp" },
.{ .path = "/usr" },
.{ .path = "/usr/lib64" },
.{ .path = "/usr/bin" },
.{ .path = "/usr/bin/ld", .executable = true },
.{ .path = "/lib" },
.{ .path = "/lib/x86_64-linux-gnu" },
.{ .path = "/lib/x86_64-linux-gnu/crt1.o" },
.{ .path = "/lib/x86_64-linux-gnu/crti.o" },
.{ .path = "/lib/x86_64-linux-gnu/crtn.o" },
.{ .path = "/lib64" },
.{ .path = "/usr/lib" },
.{ .path = "/usr/lib/gcc" },
.{ .path = "/usr/lib/gcc/x86_64-linux-gnu" },
.{ .path = "/usr/lib/gcc/x86_64-linux-gnu/9" },
.{ .path = "/usr/lib/gcc/x86_64-linux-gnu/9/crtbegin.o" },
.{ .path = "/usr/lib/gcc/x86_64-linux-gnu/9/crtend.o" },
.{ .path = "/usr/lib/x86_64-linux-gnu" },
.{ .path = "/etc/lsb-release", .contents =
\\DISTRIB_ID=Ubuntu
\\DISTRIB_RELEASE=20.04
\\DISTRIB_CODENAME=focal
\\DISTRIB_DESCRIPTION="Ubuntu 20.04.6 LTS"
\\
},
} } };
defer toolchain.deinit();
try toolchain.discover();
var argv = std.ArrayList([]const u8).init(driver.comp.gpa);
defer argv.deinit();
var linker_path_buf: [std.fs.max_path_bytes]u8 = undefined;
const linker_path = try toolchain.getLinkerPath(&linker_path_buf);
try argv.append(linker_path);
try toolchain.buildLinkerArgs(&argv);
const expected = [_][]const u8{
"/usr/bin/ld",
"-z",
"relro",
"--hash-style=gnu",
"--eh-frame-hdr",
"-m",
"elf_x86_64",
"-dynamic-linker",
"/lib64/ld-linux-x86-64.so.2",
"-o",
"a.out",
"/lib/x86_64-linux-gnu/crt1.o",
"/lib/x86_64-linux-gnu/crti.o",
"/usr/lib/gcc/x86_64-linux-gnu/9/crtbegin.o",
"-L/usr/lib/gcc/x86_64-linux-gnu/9",
"-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib64",
"-L/lib/x86_64-linux-gnu",
"-L/lib/../lib64",
"-L/usr/lib/x86_64-linux-gnu",
"-L/usr/lib/../lib64",
"-L/lib",
"-L/usr/lib",
link_obj,
"-lgcc",
"--as-needed",
"-lgcc_s",
"--no-as-needed",
"-lc",
"-lgcc",
"--as-needed",
"-lgcc_s",
"--no-as-needed",
"/usr/lib/gcc/x86_64-linux-gnu/9/crtend.o",
"/lib/x86_64-linux-gnu/crtn.o",
};
try std.testing.expectEqual(expected.len, argv.items.len);
for (expected, argv.items) |expected_item, actual_item| {
try std.testing.expectEqualStrings(expected_item, actual_item);
}
}
|
0 | repos/arocc/src/aro | repos/arocc/src/aro/char_info/identifier_tables.zig | //! Adapted from the `unicode-ident` crate: https://github.com/dtolnay/unicode-ident
//! and Unicode Standard Annex #31 https://www.unicode.org/reports/tr31/
//! Licensed under the MIT License and the Unicode license
pub const chunk = 64;
pub const trie_start: [402]u8 align(8) = .{
0x04, 0x0B, 0x0F, 0x13, 0x17, 0x1B, 0x1F, 0x23, 0x27, 0x2D, 0x31, 0x34, 0x38, 0x3C, 0x40, 0x02,
0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x00, 0x4D, 0x00, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x51, 0x54, 0x58, 0x5C, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x09, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x60, 0x64, 0x66,
0x6A, 0x6E, 0x72, 0x28, 0x76, 0x78, 0x7C, 0x80, 0x84, 0x88, 0x8C, 0x90, 0x94, 0x98, 0x9E, 0xA2,
0x05, 0x2B, 0xA6, 0x00, 0x00, 0x00, 0x00, 0x99, 0x05, 0x05, 0xA8, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x05, 0xAE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x05, 0xB1, 0x00, 0xB5, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x32, 0x05, 0x05, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9C, 0x43, 0xBB, 0x00, 0x00, 0x00, 0x00, 0xBE, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC6, 0xC8, 0x00, 0x00, 0x00, 0xAF,
0xCE, 0xD2, 0xD6, 0xBC, 0xDA, 0x00, 0x00, 0xDE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0xE0, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x52, 0xE3, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0xE6, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0xE1, 0x05, 0xE9, 0x00, 0x00, 0x00, 0x00, 0x05, 0xEB, 0x00, 0x00,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0xE4, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0xE7,
};
pub const trie_continue: [1793]u8 align(8) = .{
0x08, 0x0D, 0x11, 0x15, 0x19, 0x1D, 0x21, 0x25, 0x2A, 0x2F, 0x31, 0x36, 0x3A, 0x3E, 0x42, 0x02,
0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4B, 0x00, 0x4F, 0x00, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x51, 0x56, 0x5A, 0x5E, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x09, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x62, 0x64, 0x68,
0x6C, 0x70, 0x74, 0x28, 0x76, 0x7A, 0x7E, 0x82, 0x86, 0x8A, 0x8E, 0x92, 0x96, 0x9B, 0xA0, 0xA4,
0x05, 0x2B, 0xA6, 0x00, 0x00, 0x00, 0x00, 0x99, 0x05, 0x05, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x05, 0xAE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x05, 0xB3, 0x00, 0xB7, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x32, 0x05, 0x05, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9C, 0x43, 0xBB, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA9, 0xAC, 0xC4, 0xC6, 0xCA, 0x00, 0xCC, 0x00, 0xAF,
0xD0, 0xD4, 0xD8, 0xBC, 0xDC, 0x00, 0x00, 0xDE, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0xE0, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x52, 0xE3, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0xE6, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0xE1, 0x05, 0xE9, 0x00, 0x00, 0x00, 0x00, 0x05, 0xEB, 0x00, 0x00,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0xE4, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0xE7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xC2,
};
pub const leaf: [7584]u8 align(64) = .{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x3F, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x3F, 0xFF, 0xAA, 0xFF, 0xFF, 0xFF, 0x3F,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0x5F, 0xDC, 0x1F, 0xCF, 0x0F, 0xFF, 0x1F, 0xDC, 0x1F,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x04, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xA0, 0x04, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xFF, 0x7F, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC3, 0xFF, 0x03, 0x00, 0x1F, 0x50, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xDF, 0xB8,
0x40, 0xD7, 0xFF, 0xFF, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC3, 0xFF, 0x03, 0x00, 0x1F, 0x50, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xB8,
0xC0, 0xD7, 0xFF, 0xFF, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x03, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x7F, 0x02, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x87, 0x07, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFB, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x7F, 0x02, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x01, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0xB6, 0x00, 0xFF, 0xFF, 0xFF, 0x87, 0x07, 0x00,
0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0xC0, 0xFE, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x2F, 0x00, 0x60, 0xC0, 0x00, 0x9C,
0x00, 0x00, 0xFD, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x02, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0x07, 0x30, 0x04,
0x00, 0x00, 0xFF, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC3, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0x9F, 0xFF, 0xFD, 0xFF, 0x9F,
0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x24,
0xFF, 0xFF, 0x3F, 0x04, 0x10, 0x01, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x01, 0xFF, 0x07, 0xFF, 0xFF,
0xFF, 0x7E, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x23, 0x00, 0x00, 0x01, 0xFF, 0x03, 0x00, 0xFE, 0xFF,
0xE1, 0x9F, 0xF9, 0xFF, 0xFF, 0xFD, 0xC5, 0x23, 0x00, 0x40, 0x00, 0xB0, 0x03, 0x00, 0x03, 0x10,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0x07, 0xFF, 0xFF,
0xFF, 0x7E, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xCF, 0xFF, 0xFE, 0xFF,
0xEF, 0x9F, 0xF9, 0xFF, 0xFF, 0xFD, 0xC5, 0xF3, 0x9F, 0x79, 0x80, 0xB0, 0xCF, 0xFF, 0x03, 0x50,
0xE0, 0x87, 0xF9, 0xFF, 0xFF, 0xFD, 0x6D, 0x03, 0x00, 0x00, 0x00, 0x5E, 0x00, 0x00, 0x1C, 0x00,
0xE0, 0xBF, 0xFB, 0xFF, 0xFF, 0xFD, 0xED, 0x23, 0x00, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x02,
0xE0, 0x9F, 0xF9, 0xFF, 0xFF, 0xFD, 0xED, 0x23, 0x00, 0x00, 0x00, 0xB0, 0x03, 0x00, 0x02, 0x00,
0xE8, 0xC7, 0x3D, 0xD6, 0x18, 0xC7, 0xFF, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0xEE, 0x87, 0xF9, 0xFF, 0xFF, 0xFD, 0x6D, 0xD3, 0x87, 0x39, 0x02, 0x5E, 0xC0, 0xFF, 0x3F, 0x00,
0xEE, 0xBF, 0xFB, 0xFF, 0xFF, 0xFD, 0xED, 0xF3, 0xBF, 0x3B, 0x01, 0x00, 0xCF, 0xFF, 0x00, 0xFE,
0xEE, 0x9F, 0xF9, 0xFF, 0xFF, 0xFD, 0xED, 0xF3, 0x9F, 0x39, 0xE0, 0xB0, 0xCF, 0xFF, 0x02, 0x00,
0xEC, 0xC7, 0x3D, 0xD6, 0x18, 0xC7, 0xFF, 0xC3, 0xC7, 0x3D, 0x81, 0x00, 0xC0, 0xFF, 0x00, 0x00,
0xE0, 0xDF, 0xFD, 0xFF, 0xFF, 0xFD, 0xFF, 0x23, 0x00, 0x00, 0x00, 0x27, 0x03, 0x00, 0x00, 0x00,
0xE1, 0xDF, 0xFD, 0xFF, 0xFF, 0xFD, 0xEF, 0x23, 0x00, 0x00, 0x00, 0x60, 0x03, 0x00, 0x06, 0x00,
0xF0, 0xDF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0x27, 0x00, 0x40, 0x70, 0x80, 0x03, 0x00, 0x00, 0xFC,
0xE0, 0xFF, 0x7F, 0xFC, 0xFF, 0xFF, 0xFB, 0x2F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xDF, 0xFD, 0xFF, 0xFF, 0xFD, 0xFF, 0xF3, 0xDF, 0x3D, 0x60, 0x27, 0xCF, 0xFF, 0x00, 0x00,
0xEF, 0xDF, 0xFD, 0xFF, 0xFF, 0xFD, 0xEF, 0xF3, 0xDF, 0x3D, 0x60, 0x60, 0xCF, 0xFF, 0x0E, 0x00,
0xFF, 0xDF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0x7D, 0xF0, 0x80, 0xCF, 0xFF, 0x00, 0xFC,
0xEE, 0xFF, 0x7F, 0xFC, 0xFF, 0xFF, 0xFB, 0x2F, 0x7F, 0x84, 0x5F, 0xFF, 0xC0, 0xFF, 0x0C, 0x00,
0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x05, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xD6, 0xF7, 0xFF, 0xFF, 0xAF, 0xFF, 0x05, 0x20, 0x5F, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x1F, 0x00, 0x00,
0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xFF, 0x7F, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00,
0xD6, 0xF7, 0xFF, 0xFF, 0xAF, 0xFF, 0xFF, 0x3F, 0x5F, 0x7F, 0xFF, 0xF3, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x03, 0xFF, 0x03, 0xA0, 0xC2, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x1F, 0xFE, 0xFF,
0xDF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0x1F, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x80, 0x00, 0x00, 0x3F, 0x3C, 0x62, 0xC0, 0xE1, 0xFF,
0x03, 0x40, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0x20, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0x00, 0x00, 0x00,
0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0x20, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3D, 0x7F, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF, 0x3D, 0x7F, 0x3D, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x3F,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3D, 0x7F, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF, 0x3D, 0x7F, 0x3D, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0x00, 0xFE, 0x03, 0x00,
0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x3F,
0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9F, 0xFF, 0xFF,
0xFE, 0xFF, 0xFF, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC7, 0xFF, 0x01,
0xFF, 0xFF, 0x03, 0x80, 0xFF, 0xFF, 0x03, 0x00, 0xFF, 0xFF, 0x03, 0x00, 0xFF, 0xDF, 0x01, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x80, 0x10, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9F, 0xFF, 0xFF,
0xFE, 0xFF, 0xFF, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC7, 0xFF, 0x01,
0xFF, 0xFF, 0x3F, 0x80, 0xFF, 0xFF, 0x1F, 0x00, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xDF, 0x0D, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x8F, 0x30, 0xFF, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x05, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00,
0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x3F, 0x1F, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xB8, 0xFF, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00,
0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0x0F, 0xFF, 0x0F, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x1F, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0x03, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0x7F, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xF8, 0xFF, 0xFF, 0xFF, 0x01, 0xC0, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x9F,
0xFF, 0x03, 0xFF, 0x03, 0x80, 0x00, 0xFF, 0xBF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0xFF, 0x03, 0x00, 0xF8, 0x0F, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0x3F,
0xFF, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0x00, 0x00, 0x00, 0x00, 0x00, 0xDE, 0x6F, 0x04,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xE3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F,
0xFF, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0x00, 0x00, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0x07,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x04, 0x00, 0x00, 0x00, 0x27, 0x00, 0xF0, 0x00, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x80,
0x00, 0x00, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x84, 0xFC, 0x2F, 0x3F, 0x50, 0xFD, 0xFF, 0xF3, 0xE0, 0x43, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x80,
0x00, 0x00, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x1F, 0xE2, 0xFF, 0x01, 0x00,
0x84, 0xFC, 0x2F, 0x3F, 0x50, 0xFD, 0xFF, 0xF3, 0xE0, 0x43, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x78, 0x0C, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0x20, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x00,
0xFF, 0xFF, 0x7F, 0x00, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0xF8, 0x0F, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0x20, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x80,
0xFF, 0xFF, 0x7F, 0x00, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF,
0xE0, 0x00, 0x00, 0x00, 0xFE, 0x03, 0x3E, 0x1F, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x7F, 0xE0, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7,
0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x7F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
0xE0, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0x3E, 0x1F, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x7F, 0xE6, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x7F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x1F, 0xFF, 0xFF, 0x00, 0x0C, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x80,
0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
0x00, 0x00, 0x80, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xEB, 0x03, 0x00, 0x00, 0xFC, 0xFF,
0xFF, 0x1F, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xBF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00,
0x00, 0x00, 0x80, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xEB, 0x03, 0x00, 0x00, 0xFC, 0xFF,
0xBB, 0xF7, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00,
0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x68,
0x00, 0xFC, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x1F,
0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x80, 0x00, 0x00, 0xDF, 0xFF, 0x00, 0x7C,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x10, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0x03, 0xFF, 0xFF, 0xFF, 0xE8,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xFF, 0xFF, 0x1F,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x80, 0xFF, 0x03, 0xFF, 0xFF, 0xFF, 0x7F,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0xF7, 0x0F, 0x00, 0x00, 0xFF, 0xFF, 0x7F, 0xC4,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x62, 0x3E, 0x05, 0x00, 0x00, 0x38, 0xFF, 0x07, 0x1C, 0x00,
0x7E, 0x7E, 0x7E, 0x00, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0xFF, 0x03, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0xFF, 0x3F, 0xFF, 0x03, 0xFF, 0xFF, 0x7F, 0xFC,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x38, 0xFF, 0xFF, 0x7C, 0x00,
0x7E, 0x7E, 0x7E, 0x00, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0xFF, 0x03, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x37, 0xFF, 0x03,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00,
0x7F, 0x00, 0xF8, 0xA0, 0xFF, 0xFD, 0x7F, 0x5F, 0xDB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00,
0x7F, 0x00, 0xF8, 0xE0, 0xFF, 0xFD, 0x7F, 0x5F, 0xDB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xF0, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8A, 0xAA,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F,
0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x07, 0xFE, 0xFF, 0xFF, 0x07, 0xC0, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0x7F, 0xFC, 0xFC, 0xFC, 0x1C, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x18, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x8A, 0xAA,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F,
0x00, 0x00, 0xFF, 0x03, 0xFE, 0xFF, 0xFF, 0x87, 0xFE, 0xFF, 0xFF, 0x07, 0xE0, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFC, 0xFC, 0xFC, 0x1C, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xEF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xB7, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xEF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xB7, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0xFF, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00,
0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0xFF, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07,
0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xF7,
0xFF, 0xF7, 0xB7, 0xFF, 0xFB, 0xFF, 0xFB, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0xF7,
0xFF, 0xF7, 0xB7, 0xFF, 0xFB, 0xFF, 0xFB, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x3F, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0x91, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x7F, 0x00,
0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x37, 0x00,
0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0xEF, 0xFE, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x1F,
0xFF, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x07, 0x00,
0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x6F, 0xF0, 0xEF, 0xFE, 0xFF, 0xFF, 0x3F, 0x87, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x1F,
0xFF, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFE, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x07, 0x00,
0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0x1F, 0x80, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x7F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1B, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0,
0xFF, 0xFF, 0xFF, 0x1F, 0x80, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF,
0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x7F, 0x00,
0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x00,
0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00,
0xF8, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x90, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x47, 0x00,
0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x1E, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x3F, 0x80,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x04, 0x00, 0xFF, 0xFF, 0xFF, 0x01, 0xFF, 0x03,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xF0, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x4F, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0xDE, 0xFF, 0x17, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFB, 0xFF, 0xFF, 0x0F, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x7F, 0xBD, 0xFF, 0xBF, 0xFF, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00,
0xE0, 0x9F, 0xF9, 0xFF, 0xFF, 0xFD, 0xED, 0x23, 0x00, 0x00, 0x01, 0xE0, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x7F, 0xBD, 0xFF, 0xBF, 0xFF, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xFF, 0x03,
0xEF, 0x9F, 0xF9, 0xFF, 0xFF, 0xFD, 0xED, 0xFB, 0x9F, 0x39, 0x81, 0xE0, 0xCF, 0x1F, 0x1F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x00, 0x80, 0x07, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xB0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xFF, 0xC3, 0x03, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0x00, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0x01, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x11, 0x00, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xE7, 0xFF, 0x0F, 0xFF, 0x03, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x80,
0x7F, 0xF2, 0x6F, 0xFF, 0xFF, 0xFF, 0x00, 0x80, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x0A, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x80,
0x7F, 0xF2, 0x6F, 0xFF, 0xFF, 0xFF, 0xBF, 0xF9, 0x0F, 0x00, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x1B, 0x00, 0x00, 0x00,
0x01, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x04, 0x00, 0x00, 0x01, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x03, 0x00, 0x20, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x80, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x23, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF, 0x6F,
0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF,
0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x7F, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x40, 0x00, 0x00, 0x00, 0xBF, 0xFD, 0xFF, 0xFF,
0xFF, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0x01, 0x00, 0xFF, 0x03, 0x00, 0x00, 0xFC, 0xFF,
0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFE, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x7F, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xB4, 0xFF, 0x00, 0xFF, 0x03, 0xBF, 0xFD, 0xFF, 0xFF,
0xFF, 0x7F, 0xFB, 0x01, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x07, 0x00,
0xF4, 0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x7F, 0x00,
0xFF, 0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xC7, 0x07, 0x00, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xE3, 0x07, 0xF8,
0xE7, 0x0F, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0x7F, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0xE0,
0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0x03, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0x03, 0xFF, 0xFF, 0xFF, 0x3F, 0x1F, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x0F, 0x00, 0xFF, 0x03, 0xF8, 0xFF, 0xFF, 0xE0,
0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x87, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x80, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x03, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x6F, 0xFF, 0x7F,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xFF, 0x1F,
0xFF, 0x01, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xFF, 0x1F,
0xFF, 0x01, 0xFF, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xDF, 0x64, 0xDE, 0xFF, 0xEB, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xBF, 0xE7, 0xDF, 0xDF, 0xFF, 0xFF, 0xFF, 0x7B, 0x5F, 0xFC, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0xFD, 0xFF, 0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0xF7,
0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF,
0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFD, 0xFF, 0xFF, 0xF7, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0xFD, 0xFF, 0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0xF7,
0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xDF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF,
0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFD, 0xFF, 0xFF, 0xF7, 0xCF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x20, 0x00,
0x10, 0x00, 0x00, 0xF8, 0xFE, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x80, 0x3F, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x7F, 0xFF, 0xFF, 0xF9, 0xDB, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00,
0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0xFF, 0x3F, 0xFF, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xEF, 0xFF, 0xFF, 0xFF, 0x96, 0xFE, 0xF7, 0x0A, 0x84, 0xEA, 0x96, 0xAA, 0x96, 0xF7, 0xF7, 0x5E,
0xFF, 0xFB, 0xFF, 0x0F, 0xEE, 0xFB, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
|
0 | repos/arocc/src | repos/arocc/src/backend/Ir.zig | const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const Interner = @import("Interner.zig");
const Object = @import("Object.zig");
const Ir = @This();
interner: *Interner,
decls: std.StringArrayHashMapUnmanaged(Decl),
pub const Decl = struct {
instructions: std.MultiArrayList(Inst),
body: std.ArrayListUnmanaged(Ref),
arena: std.heap.ArenaAllocator.State,
pub fn deinit(decl: *Decl, gpa: Allocator) void {
decl.instructions.deinit(gpa);
decl.body.deinit(gpa);
decl.arena.promote(gpa).deinit();
}
};
pub const Builder = struct {
gpa: Allocator,
arena: std.heap.ArenaAllocator,
interner: *Interner,
decls: std.StringArrayHashMapUnmanaged(Decl) = .{},
instructions: std.MultiArrayList(Ir.Inst) = .{},
body: std.ArrayListUnmanaged(Ref) = .{},
alloc_count: u32 = 0,
arg_count: u32 = 0,
current_label: Ref = undefined,
pub fn deinit(b: *Builder) void {
for (b.decls.values()) |*decl| {
decl.deinit(b.gpa);
}
b.decls.deinit(b.gpa);
b.arena.deinit();
b.instructions.deinit(b.gpa);
b.body.deinit(b.gpa);
b.* = undefined;
}
pub fn finish(b: *Builder) Ir {
return .{
.interner = b.interner,
.decls = b.decls.move(),
};
}
pub fn startFn(b: *Builder) Allocator.Error!void {
const entry = try b.makeLabel("entry");
try b.body.append(b.gpa, entry);
b.current_label = entry;
}
pub fn finishFn(b: *Builder, name: []const u8) !void {
var duped_instructions = try b.instructions.clone(b.gpa);
errdefer duped_instructions.deinit(b.gpa);
var duped_body = try b.body.clone(b.gpa);
errdefer duped_body.deinit(b.gpa);
try b.decls.put(b.gpa, name, .{
.instructions = duped_instructions,
.body = duped_body,
.arena = b.arena.state,
});
b.instructions.shrinkRetainingCapacity(0);
b.body.shrinkRetainingCapacity(0);
b.arena = std.heap.ArenaAllocator.init(b.gpa);
b.alloc_count = 0;
b.arg_count = 0;
}
pub fn startBlock(b: *Builder, label: Ref) !void {
try b.body.append(b.gpa, label);
b.current_label = label;
}
pub fn addArg(b: *Builder, ty: Interner.Ref) Allocator.Error!Ref {
const ref: Ref = @enumFromInt(b.instructions.len);
try b.instructions.append(b.gpa, .{ .tag = .arg, .data = .{ .none = {} }, .ty = ty });
try b.body.insert(b.gpa, b.arg_count, ref);
b.arg_count += 1;
return ref;
}
pub fn addAlloc(b: *Builder, size: u32, @"align": u32) Allocator.Error!Ref {
const ref: Ref = @enumFromInt(b.instructions.len);
try b.instructions.append(b.gpa, .{
.tag = .alloc,
.data = .{ .alloc = .{ .size = size, .@"align" = @"align" } },
.ty = .ptr,
});
try b.body.insert(b.gpa, b.alloc_count + b.arg_count + 1, ref);
b.alloc_count += 1;
return ref;
}
pub fn addInst(b: *Builder, tag: Ir.Inst.Tag, data: Ir.Inst.Data, ty: Interner.Ref) Allocator.Error!Ref {
const ref: Ref = @enumFromInt(b.instructions.len);
try b.instructions.append(b.gpa, .{ .tag = tag, .data = data, .ty = ty });
try b.body.append(b.gpa, ref);
return ref;
}
pub fn makeLabel(b: *Builder, name: [*:0]const u8) Allocator.Error!Ref {
const ref: Ref = @enumFromInt(b.instructions.len);
try b.instructions.append(b.gpa, .{ .tag = .label, .data = .{ .label = name }, .ty = .void });
return ref;
}
pub fn addJump(b: *Builder, label: Ref) Allocator.Error!void {
_ = try b.addInst(.jmp, .{ .un = label }, .noreturn);
}
pub fn addBranch(b: *Builder, cond: Ref, true_label: Ref, false_label: Ref) Allocator.Error!void {
const branch = try b.arena.allocator().create(Ir.Inst.Branch);
branch.* = .{
.cond = cond,
.then = true_label,
.@"else" = false_label,
};
_ = try b.addInst(.branch, .{ .branch = branch }, .noreturn);
}
pub fn addSwitch(b: *Builder, target: Ref, values: []Interner.Ref, labels: []Ref, default: Ref) Allocator.Error!void {
assert(values.len == labels.len);
const a = b.arena.allocator();
const @"switch" = try a.create(Ir.Inst.Switch);
@"switch".* = .{
.target = target,
.cases_len = @intCast(values.len),
.case_vals = (try a.dupe(Interner.Ref, values)).ptr,
.case_labels = (try a.dupe(Ref, labels)).ptr,
.default = default,
};
_ = try b.addInst(.@"switch", .{ .@"switch" = @"switch" }, .noreturn);
}
pub fn addStore(b: *Builder, ptr: Ref, val: Ref) Allocator.Error!void {
_ = try b.addInst(.store, .{ .bin = .{ .lhs = ptr, .rhs = val } }, .void);
}
pub fn addConstant(b: *Builder, val: Interner.Ref, ty: Interner.Ref) Allocator.Error!Ref {
const ref: Ref = @enumFromInt(b.instructions.len);
try b.instructions.append(b.gpa, .{
.tag = .constant,
.data = .{ .constant = val },
.ty = ty,
});
return ref;
}
pub fn addPhi(b: *Builder, inputs: []const Inst.Phi.Input, ty: Interner.Ref) Allocator.Error!Ref {
const a = b.arena.allocator();
const input_refs = try a.alloc(Ref, inputs.len * 2 + 1);
input_refs[0] = @enumFromInt(inputs.len);
@memcpy(input_refs[1..], std.mem.bytesAsSlice(Ref, std.mem.sliceAsBytes(inputs)));
return b.addInst(.phi, .{ .phi = .{ .ptr = input_refs.ptr } }, ty);
}
pub fn addSelect(b: *Builder, cond: Ref, then: Ref, @"else": Ref, ty: Interner.Ref) Allocator.Error!Ref {
const branch = try b.arena.allocator().create(Ir.Inst.Branch);
branch.* = .{
.cond = cond,
.then = then,
.@"else" = @"else",
};
return b.addInst(.select, .{ .branch = branch }, ty);
}
};
pub const Renderer = struct {
gpa: Allocator,
obj: *Object,
ir: *const Ir,
errors: ErrorList = .{},
pub const ErrorList = std.StringArrayHashMapUnmanaged([]const u8);
pub const Error = Allocator.Error || error{LowerFail};
pub fn deinit(r: *Renderer) void {
for (r.errors.values()) |msg| r.gpa.free(msg);
r.errors.deinit(r.gpa);
}
pub fn render(r: *Renderer) !void {
switch (r.obj.target.cpu.arch) {
.x86, .x86_64 => return @import("Ir/x86/Renderer.zig").render(r),
else => unreachable,
}
}
pub fn fail(
r: *Renderer,
name: []const u8,
comptime format: []const u8,
args: anytype,
) Error {
try r.errors.ensureUnusedCapacity(r.gpa, 1);
r.errors.putAssumeCapacity(name, try std.fmt.allocPrint(r.gpa, format, args));
return error.LowerFail;
}
};
pub fn render(
ir: *const Ir,
gpa: Allocator,
target: std.Target,
errors: ?*Renderer.ErrorList,
) !*Object {
const obj = try Object.create(gpa, target);
errdefer obj.deinit();
var renderer: Renderer = .{
.gpa = gpa,
.obj = obj,
.ir = ir,
};
defer {
if (errors) |some| {
some.* = renderer.errors.move();
}
renderer.deinit();
}
try renderer.render();
return obj;
}
pub const Ref = enum(u32) { none = std.math.maxInt(u32), _ };
pub const Inst = struct {
tag: Tag,
data: Data,
ty: Interner.Ref,
pub const Tag = enum {
// data.constant
// not included in blocks
constant,
// data.arg
// not included in blocks
arg,
symbol,
// data.label
label,
// data.block
label_addr,
jmp,
// data.switch
@"switch",
// data.branch
branch,
select,
// data.un
jmp_val,
// data.call
call,
// data.alloc
alloc,
// data.phi
phi,
// data.bin
store,
bit_or,
bit_xor,
bit_and,
bit_shl,
bit_shr,
cmp_eq,
cmp_ne,
cmp_lt,
cmp_lte,
cmp_gt,
cmp_gte,
add,
sub,
mul,
div,
mod,
// data.un
ret,
load,
bit_not,
negate,
trunc,
zext,
sext,
};
pub const Data = union {
constant: Interner.Ref,
none: void,
bin: struct {
lhs: Ref,
rhs: Ref,
},
un: Ref,
arg: u32,
alloc: struct {
size: u32,
@"align": u32,
},
@"switch": *Switch,
call: *Call,
label: [*:0]const u8,
branch: *Branch,
phi: Phi,
};
pub const Branch = struct {
cond: Ref,
then: Ref,
@"else": Ref,
};
pub const Switch = struct {
target: Ref,
cases_len: u32,
default: Ref,
case_vals: [*]Interner.Ref,
case_labels: [*]Ref,
};
pub const Call = struct {
func: Ref,
args_len: u32,
args_ptr: [*]Ref,
pub fn args(c: Call) []Ref {
return c.args_ptr[0..c.args_len];
}
};
pub const Phi = struct {
ptr: [*]Ir.Ref,
pub const Input = struct {
label: Ir.Ref,
value: Ir.Ref,
};
pub fn inputs(p: Phi) []Input {
const len = @intFromEnum(p.ptr[0]) * 2;
const slice = (p.ptr + 1)[0..len];
return std.mem.bytesAsSlice(Input, std.mem.sliceAsBytes(slice));
}
};
};
pub fn deinit(ir: *Ir, gpa: std.mem.Allocator) void {
for (ir.decls.values()) |*decl| {
decl.deinit(gpa);
}
ir.decls.deinit(gpa);
ir.* = undefined;
}
const TYPE = std.io.tty.Color.bright_magenta;
const INST = std.io.tty.Color.bright_cyan;
const REF = std.io.tty.Color.bright_blue;
const LITERAL = std.io.tty.Color.bright_green;
const ATTRIBUTE = std.io.tty.Color.bright_yellow;
const RefMap = std.AutoArrayHashMap(Ref, void);
pub fn dump(ir: *const Ir, gpa: Allocator, config: std.io.tty.Config, w: anytype) !void {
for (ir.decls.keys(), ir.decls.values()) |name, *decl| {
try ir.dumpDecl(decl, gpa, name, config, w);
}
}
fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8, config: std.io.tty.Config, w: anytype) !void {
const tags = decl.instructions.items(.tag);
const data = decl.instructions.items(.data);
var ref_map = RefMap.init(gpa);
defer ref_map.deinit();
var label_map = RefMap.init(gpa);
defer label_map.deinit();
const ret_inst = decl.body.items[decl.body.items.len - 1];
const ret_operand = data[@intFromEnum(ret_inst)].un;
const ret_ty = decl.instructions.items(.ty)[@intFromEnum(ret_operand)];
try ir.writeType(ret_ty, config, w);
try config.setColor(w, REF);
try w.print(" @{s}", .{name});
try config.setColor(w, .reset);
try w.writeAll("(");
var arg_count: u32 = 0;
while (true) : (arg_count += 1) {
const ref = decl.body.items[arg_count];
if (tags[@intFromEnum(ref)] != .arg) break;
if (arg_count != 0) try w.writeAll(", ");
try ref_map.put(ref, {});
try ir.writeRef(decl, &ref_map, ref, config, w);
try config.setColor(w, .reset);
}
try w.writeAll(") {\n");
for (decl.body.items[arg_count..]) |ref| {
switch (tags[@intFromEnum(ref)]) {
.label => try label_map.put(ref, {}),
else => {},
}
}
for (decl.body.items[arg_count..]) |ref| {
const i = @intFromEnum(ref);
const tag = tags[i];
switch (tag) {
.arg, .constant, .symbol => unreachable,
.label => {
const label_index = label_map.getIndex(ref).?;
try config.setColor(w, REF);
try w.print("{s}.{d}:\n", .{ data[i].label, label_index });
},
// .label_val => {
// const un = data[i].un;
// try w.print(" %{d} = label.{d}\n", .{ i, @intFromEnum(un) });
// },
.jmp => {
const un = data[i].un;
try config.setColor(w, INST);
try w.writeAll(" jmp ");
try writeLabel(decl, &label_map, un, config, w);
try w.writeByte('\n');
},
.branch => {
const br = data[i].branch;
try config.setColor(w, INST);
try w.writeAll(" branch ");
try ir.writeRef(decl, &ref_map, br.cond, config, w);
try config.setColor(w, .reset);
try w.writeAll(", ");
try writeLabel(decl, &label_map, br.then, config, w);
try config.setColor(w, .reset);
try w.writeAll(", ");
try writeLabel(decl, &label_map, br.@"else", config, w);
try w.writeByte('\n');
},
.select => {
const br = data[i].branch;
try ir.writeNewRef(decl, &ref_map, ref, config, w);
try w.writeAll("select ");
try ir.writeRef(decl, &ref_map, br.cond, config, w);
try config.setColor(w, .reset);
try w.writeAll(", ");
try ir.writeRef(decl, &ref_map, br.then, config, w);
try config.setColor(w, .reset);
try w.writeAll(", ");
try ir.writeRef(decl, &ref_map, br.@"else", config, w);
try w.writeByte('\n');
},
// .jmp_val => {
// const bin = data[i].bin;
// try w.print(" %{s} %{d} label.{d}\n", .{ @tagName(tag), @intFromEnum(bin.lhs), @intFromEnum(bin.rhs) });
// },
.@"switch" => {
const @"switch" = data[i].@"switch";
try config.setColor(w, INST);
try w.writeAll(" switch ");
try ir.writeRef(decl, &ref_map, @"switch".target, config, w);
try config.setColor(w, .reset);
try w.writeAll(" {");
for (@"switch".case_vals[0..@"switch".cases_len], @"switch".case_labels) |val_ref, label_ref| {
try w.writeAll("\n ");
try ir.writeValue(val_ref, config, w);
try config.setColor(w, .reset);
try w.writeAll(" => ");
try writeLabel(decl, &label_map, label_ref, config, w);
try config.setColor(w, .reset);
}
try config.setColor(w, LITERAL);
try w.writeAll("\n default ");
try config.setColor(w, .reset);
try w.writeAll("=> ");
try writeLabel(decl, &label_map, @"switch".default, config, w);
try config.setColor(w, .reset);
try w.writeAll("\n }\n");
},
.call => {
const call = data[i].call;
try ir.writeNewRef(decl, &ref_map, ref, config, w);
try w.writeAll("call ");
try ir.writeRef(decl, &ref_map, call.func, config, w);
try config.setColor(w, .reset);
try w.writeAll("(");
for (call.args(), 0..) |arg, arg_i| {
if (arg_i != 0) try w.writeAll(", ");
try ir.writeRef(decl, &ref_map, arg, config, w);
try config.setColor(w, .reset);
}
try w.writeAll(")\n");
},
.alloc => {
const alloc = data[i].alloc;
try ir.writeNewRef(decl, &ref_map, ref, config, w);
try w.writeAll("alloc ");
try config.setColor(w, ATTRIBUTE);
try w.writeAll("size ");
try config.setColor(w, LITERAL);
try w.print("{d}", .{alloc.size});
try config.setColor(w, ATTRIBUTE);
try w.writeAll(" align ");
try config.setColor(w, LITERAL);
try w.print("{d}", .{alloc.@"align"});
try w.writeByte('\n');
},
.phi => {
try ir.writeNewRef(decl, &ref_map, ref, config, w);
try w.writeAll("phi");
try config.setColor(w, .reset);
try w.writeAll(" {");
for (data[i].phi.inputs()) |input| {
try w.writeAll("\n ");
try writeLabel(decl, &label_map, input.label, config, w);
try config.setColor(w, .reset);
try w.writeAll(" => ");
try ir.writeRef(decl, &ref_map, input.value, config, w);
try config.setColor(w, .reset);
}
try config.setColor(w, .reset);
try w.writeAll("\n }\n");
},
.store => {
const bin = data[i].bin;
try config.setColor(w, INST);
try w.writeAll(" store ");
try ir.writeRef(decl, &ref_map, bin.lhs, config, w);
try config.setColor(w, .reset);
try w.writeAll(", ");
try ir.writeRef(decl, &ref_map, bin.rhs, config, w);
try w.writeByte('\n');
},
.ret => {
try config.setColor(w, INST);
try w.writeAll(" ret ");
if (data[i].un != .none) try ir.writeRef(decl, &ref_map, data[i].un, config, w);
try w.writeByte('\n');
},
.load => {
try ir.writeNewRef(decl, &ref_map, ref, config, w);
try w.writeAll("load ");
try ir.writeRef(decl, &ref_map, data[i].un, config, w);
try w.writeByte('\n');
},
.bit_or,
.bit_xor,
.bit_and,
.bit_shl,
.bit_shr,
.cmp_eq,
.cmp_ne,
.cmp_lt,
.cmp_lte,
.cmp_gt,
.cmp_gte,
.add,
.sub,
.mul,
.div,
.mod,
=> {
const bin = data[i].bin;
try ir.writeNewRef(decl, &ref_map, ref, config, w);
try w.print("{s} ", .{@tagName(tag)});
try ir.writeRef(decl, &ref_map, bin.lhs, config, w);
try config.setColor(w, .reset);
try w.writeAll(", ");
try ir.writeRef(decl, &ref_map, bin.rhs, config, w);
try w.writeByte('\n');
},
.bit_not,
.negate,
.trunc,
.zext,
.sext,
=> {
const un = data[i].un;
try ir.writeNewRef(decl, &ref_map, ref, config, w);
try w.print("{s} ", .{@tagName(tag)});
try ir.writeRef(decl, &ref_map, un, config, w);
try w.writeByte('\n');
},
.label_addr, .jmp_val => {},
}
}
try config.setColor(w, .reset);
try w.writeAll("}\n\n");
}
fn writeType(ir: Ir, ty_ref: Interner.Ref, config: std.io.tty.Config, w: anytype) !void {
const ty = ir.interner.get(ty_ref);
try config.setColor(w, TYPE);
switch (ty) {
.ptr_ty, .noreturn_ty, .void_ty, .func_ty => try w.writeAll(@tagName(ty)),
.int_ty => |bits| try w.print("i{d}", .{bits}),
.float_ty => |bits| try w.print("f{d}", .{bits}),
.array_ty => |info| {
try w.print("[{d} * ", .{info.len});
try ir.writeType(info.child, .no_color, w);
try w.writeByte(']');
},
.vector_ty => |info| {
try w.print("<{d} * ", .{info.len});
try ir.writeType(info.child, .no_color, w);
try w.writeByte('>');
},
.record_ty => |elems| {
// TODO collect into buffer and only print once
try w.writeAll("{ ");
for (elems, 0..) |elem, i| {
if (i != 0) try w.writeAll(", ");
try ir.writeType(elem, config, w);
}
try w.writeAll(" }");
},
else => unreachable, // not a type
}
}
fn writeValue(ir: Ir, val: Interner.Ref, config: std.io.tty.Config, w: anytype) !void {
try config.setColor(w, LITERAL);
const key = ir.interner.get(val);
switch (key) {
.null => return w.writeAll("nullptr_t"),
.int => |repr| switch (repr) {
inline else => |x| return w.print("{d}", .{x}),
},
.float => |repr| switch (repr) {
inline else => |x| return w.print("{d}", .{@as(f64, @floatCast(x))}),
},
.bytes => |b| return std.zig.stringEscape(b, "", .{}, w),
else => unreachable, // not a value
}
}
fn writeRef(ir: Ir, decl: *const Decl, ref_map: *RefMap, ref: Ref, config: std.io.tty.Config, w: anytype) !void {
assert(ref != .none);
const index = @intFromEnum(ref);
const ty_ref = decl.instructions.items(.ty)[index];
if (decl.instructions.items(.tag)[index] == .constant) {
try ir.writeType(ty_ref, config, w);
const v_ref = decl.instructions.items(.data)[index].constant;
try w.writeByte(' ');
try ir.writeValue(v_ref, config, w);
return;
} else if (decl.instructions.items(.tag)[index] == .symbol) {
const name = decl.instructions.items(.data)[index].label;
try ir.writeType(ty_ref, config, w);
try config.setColor(w, REF);
try w.print(" @{s}", .{name});
return;
}
try ir.writeType(ty_ref, config, w);
try config.setColor(w, REF);
const ref_index = ref_map.getIndex(ref).?;
try w.print(" %{d}", .{ref_index});
}
fn writeNewRef(ir: Ir, decl: *const Decl, ref_map: *RefMap, ref: Ref, config: std.io.tty.Config, w: anytype) !void {
try ref_map.put(ref, {});
try w.writeAll(" ");
try ir.writeRef(decl, ref_map, ref, config, w);
try config.setColor(w, .reset);
try w.writeAll(" = ");
try config.setColor(w, INST);
}
fn writeLabel(decl: *const Decl, label_map: *RefMap, ref: Ref, config: std.io.tty.Config, w: anytype) !void {
assert(ref != .none);
const index = @intFromEnum(ref);
const label = decl.instructions.items(.data)[index].label;
try config.setColor(w, REF);
const label_index = label_map.getIndex(ref).?;
try w.print("{s}.{d}", .{ label, label_index });
}
|
0 | repos/arocc/src | repos/arocc/src/backend/Object.zig | const std = @import("std");
const Allocator = std.mem.Allocator;
const Elf = @import("Object/Elf.zig");
const Object = @This();
format: std.Target.ObjectFormat,
target: std.Target,
pub fn create(gpa: Allocator, target: std.Target) !*Object {
switch (target.ofmt) {
.elf => return Elf.create(gpa, target),
else => unreachable,
}
}
pub fn deinit(obj: *Object) void {
switch (obj.format) {
.elf => @as(*Elf, @alignCast(@fieldParentPtr("obj", obj))).deinit(),
else => unreachable,
}
}
pub const Section = union(enum) {
undefined,
data,
read_only_data,
func,
strings,
custom: []const u8,
};
pub fn getSection(obj: *Object, section: Section) !*std.ArrayList(u8) {
switch (obj.format) {
.elf => return @as(*Elf, @alignCast(@fieldParentPtr("obj", obj))).getSection(section),
else => unreachable,
}
}
pub const SymbolType = enum {
func,
variable,
external,
};
pub fn declareSymbol(
obj: *Object,
section: Section,
name: ?[]const u8,
linkage: std.builtin.GlobalLinkage,
@"type": SymbolType,
offset: u64,
size: u64,
) ![]const u8 {
switch (obj.format) {
.elf => return @as(*Elf, @alignCast(@fieldParentPtr("obj", obj))).declareSymbol(section, name, linkage, @"type", offset, size),
else => unreachable,
}
}
pub fn addRelocation(obj: *Object, name: []const u8, section: Section, address: u64, addend: i64) !void {
switch (obj.format) {
.elf => return @as(*Elf, @alignCast(@fieldParentPtr("obj", obj))).addRelocation(name, section, address, addend),
else => unreachable,
}
}
pub fn finish(obj: *Object, file: std.fs.File) !void {
switch (obj.format) {
.elf => return @as(*Elf, @alignCast(@fieldParentPtr("obj", obj))).finish(file),
else => unreachable,
}
}
|
0 | repos/arocc/src | repos/arocc/src/backend/Interner.zig | const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const BigIntConst = std.math.big.int.Const;
const BigIntMutable = std.math.big.int.Mutable;
const Hash = std.hash.Wyhash;
const Limb = std.math.big.Limb;
const Interner = @This();
map: std.AutoArrayHashMapUnmanaged(void, void) = .{},
items: std.MultiArrayList(struct {
tag: Tag,
data: u32,
}) = .{},
extra: std.ArrayListUnmanaged(u32) = .{},
limbs: std.ArrayListUnmanaged(Limb) = .{},
strings: std.ArrayListUnmanaged(u8) = .{},
const KeyAdapter = struct {
interner: *const Interner,
pub fn eql(adapter: KeyAdapter, a: Key, b_void: void, b_map_index: usize) bool {
_ = b_void;
return adapter.interner.get(@as(Ref, @enumFromInt(b_map_index))).eql(a);
}
pub fn hash(adapter: KeyAdapter, a: Key) u32 {
_ = adapter;
return a.hash();
}
};
pub const Key = union(enum) {
int_ty: u16,
float_ty: u16,
complex_ty: u16,
ptr_ty,
noreturn_ty,
void_ty,
func_ty,
array_ty: struct {
len: u64,
child: Ref,
},
vector_ty: struct {
len: u32,
child: Ref,
},
record_ty: []const Ref,
/// May not be zero
null,
int: union(enum) {
u64: u64,
i64: i64,
big_int: BigIntConst,
pub fn toBigInt(repr: @This(), space: *Tag.Int.BigIntSpace) BigIntConst {
return switch (repr) {
.big_int => |x| x,
inline .u64, .i64 => |x| BigIntMutable.init(&space.limbs, x).toConst(),
};
}
},
float: Float,
complex: Complex,
bytes: []const u8,
pub const Float = union(enum) {
f16: f16,
f32: f32,
f64: f64,
f80: f80,
f128: f128,
};
pub const Complex = union(enum) {
cf16: [2]f16,
cf32: [2]f32,
cf64: [2]f64,
cf80: [2]f80,
cf128: [2]f128,
};
pub fn hash(key: Key) u32 {
var hasher = Hash.init(0);
const tag = std.meta.activeTag(key);
std.hash.autoHash(&hasher, tag);
switch (key) {
.bytes => |bytes| {
hasher.update(bytes);
},
.record_ty => |elems| for (elems) |elem| {
std.hash.autoHash(&hasher, elem);
},
.float => |repr| switch (repr) {
inline else => |data| std.hash.autoHash(
&hasher,
@as(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),
),
},
.complex => |repr| switch (repr) {
inline else => |data| std.hash.autoHash(
&hasher,
@as(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),
),
},
.int => |repr| {
var space: Tag.Int.BigIntSpace = undefined;
const big = repr.toBigInt(&space);
std.hash.autoHash(&hasher, big.positive);
for (big.limbs) |limb| std.hash.autoHash(&hasher, limb);
},
inline else => |info| {
std.hash.autoHash(&hasher, info);
},
}
return @truncate(hasher.final());
}
pub fn eql(a: Key, b: Key) bool {
const KeyTag = std.meta.Tag(Key);
const a_tag: KeyTag = a;
const b_tag: KeyTag = b;
if (a_tag != b_tag) return false;
switch (a) {
.record_ty => |a_elems| {
const b_elems = b.record_ty;
if (a_elems.len != b_elems.len) return false;
for (a_elems, b_elems) |a_elem, b_elem| {
if (a_elem != b_elem) return false;
}
return true;
},
.bytes => |a_bytes| {
const b_bytes = b.bytes;
return std.mem.eql(u8, a_bytes, b_bytes);
},
.int => |a_repr| {
var a_space: Tag.Int.BigIntSpace = undefined;
const a_big = a_repr.toBigInt(&a_space);
var b_space: Tag.Int.BigIntSpace = undefined;
const b_big = b.int.toBigInt(&b_space);
return a_big.eql(b_big);
},
inline else => |a_info, tag| {
const b_info = @field(b, @tagName(tag));
return std.meta.eql(a_info, b_info);
},
}
}
fn toRef(key: Key) ?Ref {
switch (key) {
.int_ty => |bits| switch (bits) {
1 => return .i1,
8 => return .i8,
16 => return .i16,
32 => return .i32,
64 => return .i64,
128 => return .i128,
else => {},
},
.float_ty => |bits| switch (bits) {
16 => return .f16,
32 => return .f32,
64 => return .f64,
80 => return .f80,
128 => return .f128,
else => unreachable,
},
.complex_ty => |bits| switch (bits) {
16 => return .cf16,
32 => return .cf32,
64 => return .cf64,
80 => return .cf80,
128 => return .cf128,
else => unreachable,
},
.ptr_ty => return .ptr,
.func_ty => return .func,
.noreturn_ty => return .noreturn,
.void_ty => return .void,
.int => |repr| {
var space: Tag.Int.BigIntSpace = undefined;
const big = repr.toBigInt(&space);
if (big.eqlZero()) return .zero;
const big_one = BigIntConst{ .limbs = &.{1}, .positive = true };
if (big.eql(big_one)) return .one;
},
.float => |repr| switch (repr) {
inline else => |data| {
if (std.math.isPositiveZero(data)) return .zero;
if (data == 1) return .one;
},
},
.null => return .null,
else => {},
}
return null;
}
};
pub const Ref = enum(u32) {
const max = std.math.maxInt(u32);
ptr = max - 1,
noreturn = max - 2,
void = max - 3,
i1 = max - 4,
i8 = max - 5,
i16 = max - 6,
i32 = max - 7,
i64 = max - 8,
i128 = max - 9,
f16 = max - 10,
f32 = max - 11,
f64 = max - 12,
f80 = max - 13,
f128 = max - 14,
func = max - 15,
zero = max - 16,
one = max - 17,
null = max - 18,
cf16 = max - 19,
cf32 = max - 20,
cf64 = max - 21,
cf80 = max - 22,
cf128 = max - 23,
_,
};
pub const OptRef = enum(u32) {
const max = std.math.maxInt(u32);
none = max - 0,
ptr = max - 1,
noreturn = max - 2,
void = max - 3,
i1 = max - 4,
i8 = max - 5,
i16 = max - 6,
i32 = max - 7,
i64 = max - 8,
i128 = max - 9,
f16 = max - 10,
f32 = max - 11,
f64 = max - 12,
f80 = max - 13,
f128 = max - 14,
func = max - 15,
zero = max - 16,
one = max - 17,
null = max - 18,
cf16 = max - 19,
cf32 = max - 20,
cf64 = max - 21,
cf80 = max - 22,
cf128 = max - 23,
_,
};
pub const Tag = enum(u8) {
/// `data` is `u16`
int_ty,
/// `data` is `u16`
float_ty,
/// `data` is `u16`
complex_ty,
/// `data` is index to `Array`
array_ty,
/// `data` is index to `Vector`
vector_ty,
/// `data` is `u32`
u32,
/// `data` is `i32`
i32,
/// `data` is `Int`
int_positive,
/// `data` is `Int`
int_negative,
/// `data` is `f16`
f16,
/// `data` is `f32`
f32,
/// `data` is `F64`
f64,
/// `data` is `F80`
f80,
/// `data` is `F128`
f128,
/// `data` is `CF16`
cf16,
/// `data` is `CF32`
cf32,
/// `data` is `CF64`
cf64,
/// `data` is `CF80`
cf80,
/// `data` is `CF128`
cf128,
/// `data` is `Bytes`
bytes,
/// `data` is `Record`
record_ty,
pub const Array = struct {
len0: u32,
len1: u32,
child: Ref,
pub fn getLen(a: Array) u64 {
return (PackedU64{
.a = a.len0,
.b = a.len1,
}).get();
}
};
pub const Vector = struct {
len: u32,
child: Ref,
};
pub const Int = struct {
limbs_index: u32,
limbs_len: u32,
/// Big enough to fit any non-BigInt value
pub const BigIntSpace = struct {
/// The +1 is headroom so that operations such as incrementing once
/// or decrementing once are possible without using an allocator.
limbs: [(@sizeOf(u64) / @sizeOf(std.math.big.Limb)) + 1]std.math.big.Limb,
};
};
pub const F64 = struct {
piece0: u32,
piece1: u32,
pub fn get(self: F64) f64 {
const int_bits = @as(u64, self.piece0) | (@as(u64, self.piece1) << 32);
return @bitCast(int_bits);
}
fn pack(val: f64) F64 {
const bits = @as(u64, @bitCast(val));
return .{
.piece0 = @as(u32, @truncate(bits)),
.piece1 = @as(u32, @truncate(bits >> 32)),
};
}
};
pub const F80 = struct {
piece0: u32,
piece1: u32,
piece2: u32, // u16 part, top bits
pub fn get(self: F80) f80 {
const int_bits = @as(u80, self.piece0) |
(@as(u80, self.piece1) << 32) |
(@as(u80, self.piece2) << 64);
return @bitCast(int_bits);
}
fn pack(val: f80) F80 {
const bits = @as(u80, @bitCast(val));
return .{
.piece0 = @as(u32, @truncate(bits)),
.piece1 = @as(u32, @truncate(bits >> 32)),
.piece2 = @as(u16, @truncate(bits >> 64)),
};
}
};
pub const F128 = struct {
piece0: u32,
piece1: u32,
piece2: u32,
piece3: u32,
pub fn get(self: F128) f128 {
const int_bits = @as(u128, self.piece0) |
(@as(u128, self.piece1) << 32) |
(@as(u128, self.piece2) << 64) |
(@as(u128, self.piece3) << 96);
return @bitCast(int_bits);
}
fn pack(val: f128) F128 {
const bits = @as(u128, @bitCast(val));
return .{
.piece0 = @as(u32, @truncate(bits)),
.piece1 = @as(u32, @truncate(bits >> 32)),
.piece2 = @as(u32, @truncate(bits >> 64)),
.piece3 = @as(u32, @truncate(bits >> 96)),
};
}
};
pub const CF16 = struct {
piece0: u32,
pub fn get(self: CF16) [2]f16 {
const real: f16 = @bitCast(@as(u16, @truncate(self.piece0 >> 16)));
const imag: f16 = @bitCast(@as(u16, @truncate(self.piece0)));
return .{
real,
imag,
};
}
fn pack(val: [2]f16) CF16 {
const real: u16 = @bitCast(val[0]);
const imag: u16 = @bitCast(val[1]);
return .{
.piece0 = (@as(u32, real) << 16) | @as(u32, imag),
};
}
};
pub const CF32 = struct {
piece0: u32,
piece1: u32,
pub fn get(self: CF32) [2]f32 {
return .{
@bitCast(self.piece0),
@bitCast(self.piece1),
};
}
fn pack(val: [2]f32) CF32 {
return .{
.piece0 = @bitCast(val[0]),
.piece1 = @bitCast(val[1]),
};
}
};
pub const CF64 = struct {
piece0: u32,
piece1: u32,
piece2: u32,
piece3: u32,
pub fn get(self: CF64) [2]f64 {
return .{
(F64{ .piece0 = self.piece0, .piece1 = self.piece1 }).get(),
(F64{ .piece0 = self.piece2, .piece1 = self.piece3 }).get(),
};
}
fn pack(val: [2]f64) CF64 {
const real = F64.pack(val[0]);
const imag = F64.pack(val[1]);
return .{
.piece0 = real.piece0,
.piece1 = real.piece1,
.piece2 = imag.piece0,
.piece3 = imag.piece1,
};
}
};
/// TODO pack into 5 pieces
pub const CF80 = struct {
piece0: u32,
piece1: u32,
piece2: u32, // u16 part, top bits
piece3: u32,
piece4: u32,
piece5: u32, // u16 part, top bits
pub fn get(self: CF80) [2]f80 {
return .{
(F80{ .piece0 = self.piece0, .piece1 = self.piece1, .piece2 = self.piece2 }).get(),
(F80{ .piece0 = self.piece3, .piece1 = self.piece4, .piece2 = self.piece5 }).get(),
};
}
fn pack(val: [2]f80) CF80 {
const real = F80.pack(val[0]);
const imag = F80.pack(val[1]);
return .{
.piece0 = real.piece0,
.piece1 = real.piece1,
.piece2 = real.piece2,
.piece3 = imag.piece0,
.piece4 = imag.piece1,
.piece5 = imag.piece2,
};
}
};
pub const CF128 = struct {
piece0: u32,
piece1: u32,
piece2: u32,
piece3: u32,
piece4: u32,
piece5: u32,
piece6: u32,
piece7: u32,
pub fn get(self: CF128) [2]f128 {
return .{
(F128{ .piece0 = self.piece0, .piece1 = self.piece1, .piece2 = self.piece2, .piece3 = self.piece3 }).get(),
(F128{ .piece0 = self.piece4, .piece1 = self.piece5, .piece2 = self.piece6, .piece3 = self.piece7 }).get(),
};
}
fn pack(val: [2]f128) CF128 {
const real = F128.pack(val[0]);
const imag = F128.pack(val[1]);
return .{
.piece0 = real.piece0,
.piece1 = real.piece1,
.piece2 = real.piece2,
.piece3 = real.piece3,
.piece4 = imag.piece0,
.piece5 = imag.piece1,
.piece6 = imag.piece2,
.piece7 = imag.piece3,
};
}
};
pub const Bytes = struct {
strings_index: u32,
len: u32,
};
pub const Record = struct {
elements_len: u32,
// trailing
// [elements_len]Ref
};
};
pub const PackedU64 = packed struct(u64) {
a: u32,
b: u32,
pub fn get(x: PackedU64) u64 {
return @bitCast(x);
}
pub fn init(x: u64) PackedU64 {
return @bitCast(x);
}
};
pub fn deinit(i: *Interner, gpa: Allocator) void {
i.map.deinit(gpa);
i.items.deinit(gpa);
i.extra.deinit(gpa);
i.limbs.deinit(gpa);
i.strings.deinit(gpa);
}
pub fn put(i: *Interner, gpa: Allocator, key: Key) !Ref {
if (key.toRef()) |some| return some;
const adapter: KeyAdapter = .{ .interner = i };
const gop = try i.map.getOrPutAdapted(gpa, key, adapter);
if (gop.found_existing) return @enumFromInt(gop.index);
try i.items.ensureUnusedCapacity(gpa, 1);
switch (key) {
.int_ty => |bits| {
i.items.appendAssumeCapacity(.{
.tag = .int_ty,
.data = bits,
});
},
.float_ty => |bits| {
i.items.appendAssumeCapacity(.{
.tag = .float_ty,
.data = bits,
});
},
.complex_ty => |bits| {
i.items.appendAssumeCapacity(.{
.tag = .complex_ty,
.data = bits,
});
},
.array_ty => |info| {
const split_len = PackedU64.init(info.len);
i.items.appendAssumeCapacity(.{
.tag = .array_ty,
.data = try i.addExtra(gpa, Tag.Array{
.len0 = split_len.a,
.len1 = split_len.b,
.child = info.child,
}),
});
},
.vector_ty => |info| {
i.items.appendAssumeCapacity(.{
.tag = .vector_ty,
.data = try i.addExtra(gpa, Tag.Vector{
.len = info.len,
.child = info.child,
}),
});
},
.int => |repr| int: {
var space: Tag.Int.BigIntSpace = undefined;
const big = repr.toBigInt(&space);
switch (repr) {
.u64 => |data| if (std.math.cast(u32, data)) |small| {
i.items.appendAssumeCapacity(.{
.tag = .u32,
.data = small,
});
break :int;
},
.i64 => |data| if (std.math.cast(i32, data)) |small| {
i.items.appendAssumeCapacity(.{
.tag = .i32,
.data = @bitCast(small),
});
break :int;
},
.big_int => |data| {
if (data.fitsInTwosComp(.unsigned, 32)) {
i.items.appendAssumeCapacity(.{
.tag = .u32,
.data = data.to(u32) catch unreachable,
});
break :int;
} else if (data.fitsInTwosComp(.signed, 32)) {
i.items.appendAssumeCapacity(.{
.tag = .i32,
.data = @bitCast(data.to(i32) catch unreachable),
});
break :int;
}
},
}
const limbs_index: u32 = @intCast(i.limbs.items.len);
try i.limbs.appendSlice(gpa, big.limbs);
i.items.appendAssumeCapacity(.{
.tag = if (big.positive) .int_positive else .int_negative,
.data = try i.addExtra(gpa, Tag.Int{
.limbs_index = limbs_index,
.limbs_len = @intCast(big.limbs.len),
}),
});
},
.float => |repr| switch (repr) {
.f16 => |data| i.items.appendAssumeCapacity(.{
.tag = .f16,
.data = @as(u16, @bitCast(data)),
}),
.f32 => |data| i.items.appendAssumeCapacity(.{
.tag = .f32,
.data = @as(u32, @bitCast(data)),
}),
.f64 => |data| i.items.appendAssumeCapacity(.{
.tag = .f64,
.data = try i.addExtra(gpa, Tag.F64.pack(data)),
}),
.f80 => |data| i.items.appendAssumeCapacity(.{
.tag = .f80,
.data = try i.addExtra(gpa, Tag.F80.pack(data)),
}),
.f128 => |data| i.items.appendAssumeCapacity(.{
.tag = .f128,
.data = try i.addExtra(gpa, Tag.F128.pack(data)),
}),
},
.complex => |repr| switch (repr) {
.cf16 => |data| i.items.appendAssumeCapacity(.{
.tag = .cf16,
.data = try i.addExtra(gpa, Tag.CF16.pack(data)),
}),
.cf32 => |data| i.items.appendAssumeCapacity(.{
.tag = .cf32,
.data = try i.addExtra(gpa, Tag.CF32.pack(data)),
}),
.cf64 => |data| i.items.appendAssumeCapacity(.{
.tag = .cf64,
.data = try i.addExtra(gpa, Tag.CF64.pack(data)),
}),
.cf80 => |data| i.items.appendAssumeCapacity(.{
.tag = .cf80,
.data = try i.addExtra(gpa, Tag.CF80.pack(data)),
}),
.cf128 => |data| i.items.appendAssumeCapacity(.{
.tag = .cf128,
.data = try i.addExtra(gpa, Tag.CF128.pack(data)),
}),
},
.bytes => |bytes| {
const strings_index: u32 = @intCast(i.strings.items.len);
try i.strings.appendSlice(gpa, bytes);
i.items.appendAssumeCapacity(.{
.tag = .bytes,
.data = try i.addExtra(gpa, Tag.Bytes{
.strings_index = strings_index,
.len = @intCast(bytes.len),
}),
});
},
.record_ty => |elems| {
try i.extra.ensureUnusedCapacity(gpa, @typeInfo(Tag.Record).@"struct".fields.len +
elems.len);
i.items.appendAssumeCapacity(.{
.tag = .record_ty,
.data = i.addExtraAssumeCapacity(Tag.Record{
.elements_len = @intCast(elems.len),
}),
});
i.extra.appendSliceAssumeCapacity(@ptrCast(elems));
},
.ptr_ty,
.noreturn_ty,
.void_ty,
.func_ty,
.null,
=> unreachable,
}
return @enumFromInt(gop.index);
}
fn addExtra(i: *Interner, gpa: Allocator, extra: anytype) Allocator.Error!u32 {
const fields = @typeInfo(@TypeOf(extra)).@"struct".fields;
try i.extra.ensureUnusedCapacity(gpa, fields.len);
return i.addExtraAssumeCapacity(extra);
}
fn addExtraAssumeCapacity(i: *Interner, extra: anytype) u32 {
const result = @as(u32, @intCast(i.extra.items.len));
inline for (@typeInfo(@TypeOf(extra)).@"struct".fields) |field| {
i.extra.appendAssumeCapacity(switch (field.type) {
Ref => @intFromEnum(@field(extra, field.name)),
u32 => @field(extra, field.name),
else => @compileError("bad field type: " ++ @typeName(field.type)),
});
}
return result;
}
pub fn get(i: *const Interner, ref: Ref) Key {
switch (ref) {
.ptr => return .ptr_ty,
.func => return .func_ty,
.noreturn => return .noreturn_ty,
.void => return .void_ty,
.i1 => return .{ .int_ty = 1 },
.i8 => return .{ .int_ty = 8 },
.i16 => return .{ .int_ty = 16 },
.i32 => return .{ .int_ty = 32 },
.i64 => return .{ .int_ty = 64 },
.i128 => return .{ .int_ty = 128 },
.f16 => return .{ .float_ty = 16 },
.f32 => return .{ .float_ty = 32 },
.f64 => return .{ .float_ty = 64 },
.f80 => return .{ .float_ty = 80 },
.f128 => return .{ .float_ty = 128 },
.zero => return .{ .int = .{ .u64 = 0 } },
.one => return .{ .int = .{ .u64 = 1 } },
.null => return .null,
.cf16 => return .{ .complex_ty = 16 },
.cf32 => return .{ .complex_ty = 32 },
.cf64 => return .{ .complex_ty = 64 },
.cf80 => return .{ .complex_ty = 80 },
else => {},
}
const item = i.items.get(@intFromEnum(ref));
const data = item.data;
return switch (item.tag) {
.int_ty => .{ .int_ty = @intCast(data) },
.float_ty => .{ .float_ty = @intCast(data) },
.complex_ty => .{ .complex_ty = @intCast(data) },
.array_ty => {
const array_ty = i.extraData(Tag.Array, data);
return .{ .array_ty = .{
.len = array_ty.getLen(),
.child = array_ty.child,
} };
},
.vector_ty => {
const vector_ty = i.extraData(Tag.Vector, data);
return .{ .vector_ty = .{
.len = vector_ty.len,
.child = vector_ty.child,
} };
},
.u32 => .{ .int = .{ .u64 = data } },
.i32 => .{ .int = .{ .i64 = @as(i32, @bitCast(data)) } },
.int_positive, .int_negative => {
const int_info = i.extraData(Tag.Int, data);
const limbs = i.limbs.items[int_info.limbs_index..][0..int_info.limbs_len];
return .{ .int = .{
.big_int = .{
.positive = item.tag == .int_positive,
.limbs = limbs,
},
} };
},
.f16 => .{ .float = .{ .f16 = @bitCast(@as(u16, @intCast(data))) } },
.f32 => .{ .float = .{ .f32 = @bitCast(data) } },
.f64 => {
const float = i.extraData(Tag.F64, data);
return .{ .float = .{ .f64 = float.get() } };
},
.f80 => {
const float = i.extraData(Tag.F80, data);
return .{ .float = .{ .f80 = float.get() } };
},
.f128 => {
const float = i.extraData(Tag.F128, data);
return .{ .float = .{ .f128 = float.get() } };
},
.cf16 => {
const components = i.extraData(Tag.CF16, data);
return .{ .complex = .{ .cf16 = components.get() } };
},
.cf32 => {
const components = i.extraData(Tag.CF32, data);
return .{ .complex = .{ .cf32 = components.get() } };
},
.cf64 => {
const components = i.extraData(Tag.CF64, data);
return .{ .complex = .{ .cf64 = components.get() } };
},
.cf80 => {
const components = i.extraData(Tag.CF80, data);
return .{ .complex = .{ .cf80 = components.get() } };
},
.cf128 => {
const components = i.extraData(Tag.CF128, data);
return .{ .complex = .{ .cf128 = components.get() } };
},
.bytes => {
const bytes = i.extraData(Tag.Bytes, data);
return .{ .bytes = i.strings.items[bytes.strings_index..][0..bytes.len] };
},
.record_ty => {
const extra = i.extraDataTrail(Tag.Record, data);
return .{
.record_ty = @ptrCast(i.extra.items[extra.end..][0..extra.data.elements_len]),
};
},
};
}
fn extraData(i: *const Interner, comptime T: type, index: usize) T {
return i.extraDataTrail(T, index).data;
}
fn extraDataTrail(i: *const Interner, comptime T: type, index: usize) struct { data: T, end: u32 } {
var result: T = undefined;
const fields = @typeInfo(T).@"struct".fields;
inline for (fields, 0..) |field, field_i| {
const int32 = i.extra.items[field_i + index];
@field(result, field.name) = switch (field.type) {
Ref => @enumFromInt(int32),
u32 => int32,
else => @compileError("bad field type: " ++ @typeName(field.type)),
};
}
return .{
.data = result,
.end = @intCast(index + fields.len),
};
}
|
0 | repos/arocc/src/backend/Ir | repos/arocc/src/backend/Ir/x86/Renderer.zig | const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const Interner = @import("../../Interner.zig");
const Ir = @import("../../Ir.zig");
const BaseRenderer = Ir.Renderer;
const zig = @import("zig");
const abi = zig.arch.x86_64.abi;
const bits = zig.arch.x86_64.bits;
const Condition = bits.Condition;
const Immediate = bits.Immediate;
const Memory = bits.Memory;
const Register = bits.Register;
const RegisterLock = RegisterManager.RegisterLock;
const FrameIndex = bits.FrameIndex;
const RegisterManager = zig.RegisterManager(Renderer, Register, Ir.Ref, abi.allocatable_regs);
// Register classes
const RegisterBitSet = RegisterManager.RegisterBitSet;
const RegisterClass = struct {
const gp: RegisterBitSet = blk: {
var set = RegisterBitSet.initEmpty();
for (abi.allocatable_regs, 0..) |reg, index| if (reg.class() == .general_purpose) set.set(index);
break :blk set;
};
const x87: RegisterBitSet = blk: {
var set = RegisterBitSet.initEmpty();
for (abi.allocatable_regs, 0..) |reg, index| if (reg.class() == .x87) set.set(index);
break :blk set;
};
const sse: RegisterBitSet = blk: {
var set = RegisterBitSet.initEmpty();
for (abi.allocatable_regs, 0..) |reg, index| if (reg.class() == .sse) set.set(index);
break :blk set;
};
};
const Renderer = @This();
base: *BaseRenderer,
interner: *Interner,
register_manager: RegisterManager = .{},
pub fn render(base: *BaseRenderer) !void {
var renderer: Renderer = .{
.base = base,
.interner = base.ir.interner,
};
for (renderer.base.ir.decls.keys(), renderer.base.ir.decls.values()) |name, decl| {
renderer.renderFn(name, decl) catch |e| switch (e) {
error.OutOfMemory => return e,
error.LowerFail => continue,
};
}
if (renderer.base.errors.entries.len != 0) return error.LowerFail;
}
fn renderFn(r: *Renderer, name: []const u8, decl: Ir.Decl) !void {
_ = decl;
return r.base.fail(name, "TODO implement lowering functions", .{});
}
|
0 | repos/arocc/src/backend | repos/arocc/src/backend/Object/Elf.zig | const std = @import("std");
const Allocator = std.mem.Allocator;
const Target = std.Target;
const Object = @import("../Object.zig");
const Section = struct {
data: std.ArrayList(u8),
relocations: std.ArrayListUnmanaged(Relocation) = .{},
flags: u64,
type: u32,
index: u16 = undefined,
};
const Symbol = struct {
section: ?*Section,
size: u64,
offset: u64,
index: u16 = undefined,
info: u8,
};
const Relocation = struct {
symbol: *Symbol,
addend: i64,
offset: u48,
type: u8,
};
const additional_sections = 3; // null section, strtab, symtab
const strtab_index = 1;
const symtab_index = 2;
const strtab_default = "\x00.strtab\x00.symtab\x00";
const strtab_name = 1;
const symtab_name = "\x00.strtab\x00".len;
const Elf = @This();
obj: Object,
/// The keys are owned by the Codegen.tree
sections: std.StringHashMapUnmanaged(*Section) = .{},
local_symbols: std.StringHashMapUnmanaged(*Symbol) = .{},
global_symbols: std.StringHashMapUnmanaged(*Symbol) = .{},
unnamed_symbol_mangle: u32 = 0,
strtab_len: u64 = strtab_default.len,
arena: std.heap.ArenaAllocator,
pub fn create(gpa: Allocator, target: Target) !*Object {
const elf = try gpa.create(Elf);
elf.* = .{
.obj = .{ .format = .elf, .target = target },
.arena = std.heap.ArenaAllocator.init(gpa),
};
return &elf.obj;
}
pub fn deinit(elf: *Elf) void {
const gpa = elf.arena.child_allocator;
{
var it = elf.sections.valueIterator();
while (it.next()) |sect| {
sect.*.data.deinit();
sect.*.relocations.deinit(gpa);
}
}
elf.sections.deinit(gpa);
elf.local_symbols.deinit(gpa);
elf.global_symbols.deinit(gpa);
elf.arena.deinit();
gpa.destroy(elf);
}
fn sectionString(sec: Object.Section) []const u8 {
return switch (sec) {
.undefined => unreachable,
.data => "data",
.read_only_data => "rodata",
.func => "text",
.strings => "rodata.str",
.custom => |name| name,
};
}
pub fn getSection(elf: *Elf, section_kind: Object.Section) !*std.ArrayList(u8) {
const section_name = sectionString(section_kind);
const section = elf.sections.get(section_name) orelse blk: {
const section = try elf.arena.allocator().create(Section);
section.* = .{
.data = std.ArrayList(u8).init(elf.arena.child_allocator),
.type = std.elf.SHT_PROGBITS,
.flags = switch (section_kind) {
.func, .custom => std.elf.SHF_ALLOC + std.elf.SHF_EXECINSTR,
.strings => std.elf.SHF_ALLOC + std.elf.SHF_MERGE + std.elf.SHF_STRINGS,
.read_only_data => std.elf.SHF_ALLOC,
.data => std.elf.SHF_ALLOC + std.elf.SHF_WRITE,
.undefined => unreachable,
},
};
try elf.sections.putNoClobber(elf.arena.child_allocator, section_name, section);
elf.strtab_len += section_name.len + ".\x00".len;
break :blk section;
};
return §ion.data;
}
pub fn declareSymbol(
elf: *Elf,
section_kind: Object.Section,
maybe_name: ?[]const u8,
linkage: std.builtin.GlobalLinkage,
@"type": Object.SymbolType,
offset: u64,
size: u64,
) ![]const u8 {
const section = blk: {
if (section_kind == .undefined) break :blk null;
const section_name = sectionString(section_kind);
break :blk elf.sections.get(section_name);
};
const binding: u8 = switch (linkage) {
.Internal => std.elf.STB_LOCAL,
.Strong => std.elf.STB_GLOBAL,
.Weak => std.elf.STB_WEAK,
.LinkOnce => unreachable,
};
const sym_type: u8 = switch (@"type") {
.func => std.elf.STT_FUNC,
.variable => std.elf.STT_OBJECT,
.external => std.elf.STT_NOTYPE,
};
const name = if (maybe_name) |some| some else blk: {
defer elf.unnamed_symbol_mangle += 1;
break :blk try std.fmt.allocPrint(elf.arena.allocator(), ".L.{d}", .{elf.unnamed_symbol_mangle});
};
const gop = if (linkage == .Internal)
try elf.local_symbols.getOrPut(elf.arena.child_allocator, name)
else
try elf.global_symbols.getOrPut(elf.arena.child_allocator, name);
if (!gop.found_existing) {
gop.value_ptr.* = try elf.arena.allocator().create(Symbol);
elf.strtab_len += name.len + 1; // +1 for null byte
}
gop.value_ptr.*.* = .{
.section = section,
.size = size,
.offset = offset,
.info = (binding << 4) + sym_type,
};
return name;
}
pub fn addRelocation(elf: *Elf, name: []const u8, section_kind: Object.Section, address: u64, addend: i64) !void {
const section_name = sectionString(section_kind);
const symbol = elf.local_symbols.get(name) orelse elf.global_symbols.get(name).?; // reference to undeclared symbol
const section = elf.sections.get(section_name).?;
if (section.relocations.items.len == 0) elf.strtab_len += ".rela".len;
try section.relocations.append(elf.arena.child_allocator, .{
.symbol = symbol,
.offset = @intCast(address),
.addend = addend,
.type = if (symbol.section == null) 4 else 2, // TODO
});
}
/// elf header
/// sections contents
/// symbols
/// relocations
/// strtab
/// section headers
pub fn finish(elf: *Elf, file: std.fs.File) !void {
var buf_writer = std.io.bufferedWriter(file.writer());
const w = buf_writer.writer();
var num_sections: std.elf.Elf64_Half = additional_sections;
var relocations_len: std.elf.Elf64_Off = 0;
var sections_len: std.elf.Elf64_Off = 0;
{
var it = elf.sections.valueIterator();
while (it.next()) |sect| {
sections_len += sect.*.data.items.len;
relocations_len += sect.*.relocations.items.len * @sizeOf(std.elf.Elf64_Rela);
sect.*.index = num_sections;
num_sections += 1;
num_sections += @intFromBool(sect.*.relocations.items.len != 0);
}
}
const symtab_len = (elf.local_symbols.count() + elf.global_symbols.count() + 1) * @sizeOf(std.elf.Elf64_Sym);
const symtab_offset = @sizeOf(std.elf.Elf64_Ehdr) + sections_len;
const symtab_offset_aligned = std.mem.alignForward(u64, symtab_offset, 8);
const rela_offset = symtab_offset_aligned + symtab_len;
const strtab_offset = rela_offset + relocations_len;
const sh_offset = strtab_offset + elf.strtab_len;
const sh_offset_aligned = std.mem.alignForward(u64, sh_offset, 16);
const elf_header = std.elf.Elf64_Ehdr{
.e_ident = .{ 0x7F, 'E', 'L', 'F', 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
.e_type = std.elf.ET.REL, // we only produce relocatables
.e_machine = elf.obj.target.toElfMachine(),
.e_version = 1,
.e_entry = 0, // linker will handle this
.e_phoff = 0, // no program header
.e_shoff = sh_offset_aligned, // section headers offset
.e_flags = 0, // no flags
.e_ehsize = @sizeOf(std.elf.Elf64_Ehdr),
.e_phentsize = 0, // no program header
.e_phnum = 0, // no program header
.e_shentsize = @sizeOf(std.elf.Elf64_Shdr),
.e_shnum = num_sections,
.e_shstrndx = strtab_index,
};
try w.writeStruct(elf_header);
// write contents of sections
{
var it = elf.sections.valueIterator();
while (it.next()) |sect| try w.writeAll(sect.*.data.items);
}
// pad to 8 bytes
try w.writeByteNTimes(0, @intCast(symtab_offset_aligned - symtab_offset));
var name_offset: u32 = strtab_default.len;
// write symbols
{
// first symbol must be null
try w.writeStruct(std.mem.zeroes(std.elf.Elf64_Sym));
var sym_index: u16 = 1;
var it = elf.local_symbols.iterator();
while (it.next()) |entry| {
const sym = entry.value_ptr.*;
try w.writeStruct(std.elf.Elf64_Sym{
.st_name = name_offset,
.st_info = sym.info,
.st_other = 0,
.st_shndx = if (sym.section) |some| some.index else 0,
.st_value = sym.offset,
.st_size = sym.size,
});
sym.index = sym_index;
sym_index += 1;
name_offset += @intCast(entry.key_ptr.len + 1); // +1 for null byte
}
it = elf.global_symbols.iterator();
while (it.next()) |entry| {
const sym = entry.value_ptr.*;
try w.writeStruct(std.elf.Elf64_Sym{
.st_name = name_offset,
.st_info = sym.info,
.st_other = 0,
.st_shndx = if (sym.section) |some| some.index else 0,
.st_value = sym.offset,
.st_size = sym.size,
});
sym.index = sym_index;
sym_index += 1;
name_offset += @intCast(entry.key_ptr.len + 1); // +1 for null byte
}
}
// write relocations
{
var it = elf.sections.valueIterator();
while (it.next()) |sect| {
for (sect.*.relocations.items) |rela| {
try w.writeStruct(std.elf.Elf64_Rela{
.r_offset = rela.offset,
.r_addend = rela.addend,
.r_info = (@as(u64, rela.symbol.index) << 32) | rela.type,
});
}
}
}
// write strtab
try w.writeAll(strtab_default);
{
var it = elf.local_symbols.keyIterator();
while (it.next()) |key| try w.print("{s}\x00", .{key.*});
it = elf.global_symbols.keyIterator();
while (it.next()) |key| try w.print("{s}\x00", .{key.*});
}
{
var it = elf.sections.iterator();
while (it.next()) |entry| {
if (entry.value_ptr.*.relocations.items.len != 0) try w.writeAll(".rela");
try w.print(".{s}\x00", .{entry.key_ptr.*});
}
}
// pad to 16 bytes
try w.writeByteNTimes(0, @intCast(sh_offset_aligned - sh_offset));
// mandatory null header
try w.writeStruct(std.mem.zeroes(std.elf.Elf64_Shdr));
// write strtab section header
{
const sect_header = std.elf.Elf64_Shdr{
.sh_name = strtab_name,
.sh_type = std.elf.SHT_STRTAB,
.sh_flags = 0,
.sh_addr = 0,
.sh_offset = strtab_offset,
.sh_size = elf.strtab_len,
.sh_link = 0,
.sh_info = 0,
.sh_addralign = 1,
.sh_entsize = 0,
};
try w.writeStruct(sect_header);
}
// write symtab section header
{
const sect_header = std.elf.Elf64_Shdr{
.sh_name = symtab_name,
.sh_type = std.elf.SHT_SYMTAB,
.sh_flags = 0,
.sh_addr = 0,
.sh_offset = symtab_offset_aligned,
.sh_size = symtab_len,
.sh_link = strtab_index,
.sh_info = elf.local_symbols.size + 1,
.sh_addralign = 8,
.sh_entsize = @sizeOf(std.elf.Elf64_Sym),
};
try w.writeStruct(sect_header);
}
// remaining section headers
{
var sect_offset: u64 = @sizeOf(std.elf.Elf64_Ehdr);
var rela_sect_offset: u64 = rela_offset;
var it = elf.sections.iterator();
while (it.next()) |entry| {
const sect = entry.value_ptr.*;
const rela_count = sect.relocations.items.len;
const rela_name_offset: u32 = if (rela_count != 0) @truncate(".rela".len) else 0;
try w.writeStruct(std.elf.Elf64_Shdr{
.sh_name = rela_name_offset + name_offset,
.sh_type = sect.type,
.sh_flags = sect.flags,
.sh_addr = 0,
.sh_offset = sect_offset,
.sh_size = sect.data.items.len,
.sh_link = 0,
.sh_info = 0,
.sh_addralign = if (sect.flags & std.elf.SHF_EXECINSTR != 0) 16 else 1,
.sh_entsize = 0,
});
if (rela_count != 0) {
const size = rela_count * @sizeOf(std.elf.Elf64_Rela);
try w.writeStruct(std.elf.Elf64_Shdr{
.sh_name = name_offset,
.sh_type = std.elf.SHT_RELA,
.sh_flags = 0,
.sh_addr = 0,
.sh_offset = rela_sect_offset,
.sh_size = rela_count * @sizeOf(std.elf.Elf64_Rela),
.sh_link = symtab_index,
.sh_info = sect.index,
.sh_addralign = 8,
.sh_entsize = @sizeOf(std.elf.Elf64_Rela),
});
rela_sect_offset += size;
}
sect_offset += sect.data.items.len;
name_offset += @as(u32, @intCast(entry.key_ptr.len + ".\x00".len)) + rela_name_offset;
}
}
try buf_writer.flush();
}
|
0 | repos/arocc | repos/arocc/test/runner.zig | const std = @import("std");
const build_options = @import("build_options");
const print = std.debug.print;
const aro = @import("aro");
const CodeGen = aro.CodeGen;
const Tree = aro.Tree;
const Token = Tree.Token;
const NodeIndex = Tree.NodeIndex;
const AllocatorError = std.mem.Allocator.Error;
var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
const AddCommandLineArgsResult = struct {
bool,
aro.Preprocessor.Linemarkers,
aro.Compilation.SystemDefinesMode,
aro.Preprocessor.DumpMode,
};
/// Returns only_preprocess and line_markers settings if saw -E
fn addCommandLineArgs(comp: *aro.Compilation, file: aro.Source, macro_buf: anytype) !AddCommandLineArgsResult {
var only_preprocess = false;
var line_markers: aro.Preprocessor.Linemarkers = .none;
var system_defines: aro.Compilation.SystemDefinesMode = .include_system_defines;
var dump_mode: aro.Preprocessor.DumpMode = .result_only;
comp.langopts.gnuc_version = 40201; // Set to clang default value since we do not call parseArgs if there are no args
if (std.mem.startsWith(u8, file.buf, "//aro-args")) {
var test_args = std.ArrayList([]const u8).init(comp.gpa);
defer test_args.deinit();
const nl = std.mem.indexOfAny(u8, file.buf, "\n\r") orelse file.buf.len;
var it = std.mem.tokenizeScalar(u8, file.buf[0..nl], ' ');
while (it.next()) |some| try test_args.append(some);
var driver: aro.Driver = .{ .comp = comp };
defer driver.deinit();
_ = try driver.parseArgs(std.io.null_writer, macro_buf, test_args.items);
only_preprocess = driver.only_preprocess;
system_defines = driver.system_defines;
dump_mode = driver.debug_dump_letters.getPreprocessorDumpMode();
if (only_preprocess) {
if (driver.line_commands) {
line_markers = if (driver.use_line_directives) .line_directives else .numeric_directives;
}
}
}
if (std.mem.indexOf(u8, file.buf, "//aro-env")) |idx| {
const buf = file.buf[idx..];
const nl = std.mem.indexOfAny(u8, buf, "\n\r") orelse buf.len;
var it = std.mem.tokenizeScalar(u8, buf[0..nl], ' ');
while (it.next()) |some| {
var parts = std.mem.splitScalar(u8, some, '=');
const name = parts.next().?;
const val = parts.next() orelse "";
inline for (@typeInfo(aro.Compilation.Environment).@"struct".fields) |field| {
if (std.ascii.eqlIgnoreCase(name, field.name)) {
@field(comp.environment, field.name) = val;
}
}
}
}
return .{ only_preprocess, line_markers, system_defines, dump_mode };
}
fn testOne(allocator: std.mem.Allocator, path: []const u8, test_dir: []const u8) !void {
var comp = aro.Compilation.init(allocator, std.fs.cwd());
defer comp.deinit();
try comp.addDefaultPragmaHandlers();
try comp.addBuiltinIncludeDir(test_dir);
const file = try comp.addSourceFromPath(path);
var macro_buf = std.ArrayList(u8).init(comp.gpa);
defer macro_buf.deinit();
_, _, const system_defines, _ = try addCommandLineArgs(&comp, file, macro_buf.writer());
const user_macros = try comp.addSourceFromBuffer("<command line>", macro_buf.items);
const builtin_macros = try comp.generateBuiltinMacros(system_defines);
var pp = aro.Preprocessor.init(&comp);
defer pp.deinit();
try pp.addBuiltinMacros();
if (comp.langopts.ms_extensions) {
comp.ms_cwd_source_id = file.id;
}
_ = try pp.preprocess(builtin_macros);
_ = try pp.preprocess(user_macros);
const eof = try pp.preprocess(file);
try pp.addToken(eof);
var tree = try aro.Parser.parse(&pp);
defer tree.deinit();
tree.dump(false, std.io.null_writer) catch {};
}
fn testAllAllocationFailures(cases: [][]const u8, test_dir: []const u8) !void {
const root_node = std.Progress.start(.{
.disable_printing = false,
.root_name = "Memory Allocation Test",
.estimated_total_items = cases.len,
});
for (cases) |case| {
const case_name = std.mem.sliceTo(std.fs.path.basename(case), '.');
var case_node = root_node.start(case_name, 0);
defer case_node.end();
std.testing.checkAllAllocationFailures(std.testing.allocator, testOne, .{ case, test_dir }) catch |er| switch (er) {
error.SwallowedOutOfMemoryError => {},
else => |e| return e,
};
}
root_node.end();
}
pub fn main() !void {
const gpa = general_purpose_allocator.allocator();
defer if (general_purpose_allocator.deinit() == .leak) std.process.exit(1);
const args = try std.process.argsAlloc(gpa);
defer std.process.argsFree(gpa, args);
if (args.len != 3) {
print("expected test case directory and zig executable as only arguments\n", .{});
return error.InvalidArguments;
}
const test_dir = args[1];
var buf = std.ArrayList(u8).init(gpa);
var cases = std.ArrayList([]const u8).init(gpa);
defer {
for (cases.items) |path| gpa.free(path);
cases.deinit();
buf.deinit();
}
// collect all cases
{
var cases_dir = try std.fs.cwd().openDir(args[1], .{ .iterate = true });
defer cases_dir.close();
var it = cases_dir.iterate();
while (try it.next()) |entry| {
if (entry.kind == .directory) continue;
if (entry.kind != .file) {
print("skipping non file entry '{s}'\n", .{entry.name});
continue;
}
defer buf.items.len = 0;
try buf.writer().print("{s}{c}{s}", .{ args[1], std.fs.path.sep, entry.name });
try cases.append(try gpa.dupe(u8, buf.items));
}
}
if (build_options.test_all_allocation_failures) {
return testAllAllocationFailures(cases.items, test_dir);
}
const root_node = std.Progress.start(.{
.disable_printing = false,
.root_name = "Test",
.estimated_total_items = cases.items.len,
});
// prepare compiler
var initial_comp = aro.Compilation.init(gpa, std.fs.cwd());
defer initial_comp.deinit();
const cases_include_dir = try std.fs.path.join(gpa, &.{ args[1], "include" });
defer gpa.free(cases_include_dir);
try initial_comp.include_dirs.append(gpa, cases_include_dir);
const cases_next_include_dir = try std.fs.path.join(gpa, &.{ args[1], "include", "next" });
defer gpa.free(cases_next_include_dir);
try initial_comp.include_dirs.append(gpa, cases_next_include_dir);
try initial_comp.addDefaultPragmaHandlers();
try initial_comp.addBuiltinIncludeDir(test_dir);
// apparently we can't use setAstCwd without libc on windows yet
const win = @import("builtin").os.tag == .windows;
var tmp_dir = if (!win) std.testing.tmpDir(.{});
defer if (!win) tmp_dir.cleanup();
if (!win) try tmp_dir.dir.setAsCwd();
// iterate over all cases
var ok_count: u32 = 0;
var fail_count: u32 = 0;
var skip_count: u32 = 0;
next_test: for (cases.items) |path| {
var comp = initial_comp;
defer {
// preserve some values
comp.include_dirs = .{};
comp.system_include_dirs = .{};
comp.pragma_handlers = .{};
comp.environment = .{};
// reset everything else
comp.deinit();
}
const case = std.mem.sliceTo(std.fs.path.basename(path), '.');
var case_node = root_node.start(case, 0);
defer case_node.end();
const file = comp.addSourceFromPath(path) catch |err| {
fail_count += 1;
std.debug.print("could not add source '{s}': {s}\n", .{ path, @errorName(err) });
continue;
};
var macro_buf = std.ArrayList(u8).init(comp.gpa);
defer macro_buf.deinit();
const only_preprocess, const linemarkers, const system_defines, const dump_mode = try addCommandLineArgs(&comp, file, macro_buf.writer());
const user_macros = try comp.addSourceFromBuffer("<command line>", macro_buf.items);
const builtin_macros = try comp.generateBuiltinMacros(system_defines);
comp.diagnostics.errors = 0;
var pp = aro.Preprocessor.init(&comp);
defer pp.deinit();
if (only_preprocess) {
pp.preserve_whitespace = true;
pp.linemarkers = linemarkers;
if (dump_mode != .result_only) {
pp.store_macro_tokens = true;
}
}
try pp.addBuiltinMacros();
if (comp.langopts.ms_extensions) {
comp.ms_cwd_source_id = file.id;
}
_ = try pp.preprocess(builtin_macros);
_ = try pp.preprocess(user_macros);
const eof = pp.preprocess(file) catch |err| {
fail_count += 1;
std.debug.print("could not preprocess file '{s}': {s}\n", .{ path, @errorName(err) });
continue;
};
try pp.addToken(eof);
if (pp.defines.get("TESTS_SKIPPED")) |macro| {
if (macro.is_func or macro.tokens.len != 1 or macro.tokens[0].id != .pp_num) {
fail_count += 1;
std.debug.print("invalid TESTS_SKIPPED, definition should contain exactly one integer literal {}\n", .{macro});
continue;
}
const tok_slice = pp.tokSlice(macro.tokens[0]);
const tests_skipped = try std.fmt.parseInt(u32, tok_slice, 0);
std.debug.print("{s}: {d} test{s} skipped\n", .{ case, tests_skipped, if (tests_skipped == 1) @as([]const u8, "") else "s" });
skip_count += tests_skipped;
}
if (only_preprocess) {
if (try checkExpectedErrors(&pp, &buf)) |some| {
if (!some) {
fail_count += 1;
continue;
}
} else {
aro.Diagnostics.render(&comp, std.io.tty.detectConfig(std.io.getStdErr()));
if (comp.diagnostics.errors != 0) {
fail_count += 1;
continue;
}
}
const expected_output = blk: {
const expanded_path = try std.fs.path.join(gpa, &.{ args[1], "expanded", std.fs.path.basename(path) });
defer gpa.free(expanded_path);
break :blk std.fs.cwd().readFileAlloc(gpa, expanded_path, std.math.maxInt(u32)) catch |err| {
fail_count += 1;
std.debug.print("could not open expanded file '{s}': {s}\n", .{ path, @errorName(err) });
continue;
};
};
defer gpa.free(expected_output);
var output = std.ArrayList(u8).init(gpa);
defer output.deinit();
try pp.prettyPrintTokens(output.writer(), dump_mode);
if (pp.defines.contains("CHECK_PARTIAL_MATCH")) {
const index = std.mem.indexOf(u8, output.items, expected_output);
if (index != null) {
ok_count += 1;
} else {
fail_count += 1;
std.debug.print("\n====== expected to find: =========\n", .{});
std.debug.print("{s}", .{expected_output});
std.debug.print("\n======== but did not find it in this: =========\n", .{});
std.debug.print("{s}", .{output.items});
std.debug.print("\n======================================\n", .{});
}
} else {
if (std.testing.expectEqualStrings(expected_output, output.items))
ok_count += 1
else |_|
fail_count += 1;
}
continue;
}
const expected_types = pp.defines.get("EXPECTED_TYPES");
var tree = aro.Parser.parse(&pp) catch |err| switch (err) {
error.FatalError => {
if (try checkExpectedErrors(&pp, &buf)) |some| {
if (some) ok_count += 1 else fail_count += 1;
}
continue;
},
else => |e| return e,
};
defer tree.deinit();
const ast_path = try std.fs.path.join(gpa, &.{ args[1], "ast", std.fs.path.basename(path) });
defer gpa.free(ast_path);
const maybe_ast = std.fs.cwd().readFileAlloc(gpa, ast_path, std.math.maxInt(u32)) catch null;
if (maybe_ast) |expected_ast| {
defer gpa.free(expected_ast);
var actual_ast = std.ArrayList(u8).init(gpa);
defer actual_ast.deinit();
try tree.dump(.no_color, actual_ast.writer());
std.testing.expectEqualStrings(expected_ast, actual_ast.items) catch {
fail_count += 1;
break;
};
} else tree.dump(.no_color, std.io.null_writer) catch {};
if (expected_types) |types| {
const test_fn = for (tree.root_decls) |decl| {
if (tree.nodes.items(.tag)[@intFromEnum(decl)] == .fn_def) break tree.nodes.items(.data)[@intFromEnum(decl)];
} else {
fail_count += 1;
std.debug.print("EXPECTED_TYPES requires a function to be defined\n", .{});
break;
};
var actual = StmtTypeDumper.init(gpa);
defer actual.deinit(gpa);
const mapper = try tree.comp.string_interner.getFastTypeMapper(gpa);
defer mapper.deinit(gpa);
try actual.dump(&tree, mapper, test_fn.decl.node, gpa);
var i: usize = 0;
for (types.tokens) |str| {
if (str.id == .macro_ws) continue;
if (str.id != .string_literal) {
fail_count += 1;
std.debug.print("EXPECTED_TYPES tokens must be string literals (found {s})\n", .{@tagName(str.id)});
continue :next_test;
}
defer i += 1;
if (i >= actual.types.items.len) continue;
const expected_type = std.mem.trim(u8, pp.tokSlice(str), "\"");
const actual_type = actual.types.items[i];
if (!std.mem.eql(u8, expected_type, actual_type)) {
fail_count += 1;
std.debug.print("expected type '{s}' did not match actual type '{s}'\n", .{
expected_type,
actual_type,
});
continue :next_test;
}
}
if (i != actual.types.items.len) {
fail_count += 1;
std.debug.print(
"EXPECTED_TYPES count differs: expected {d} found {d}\n",
.{ i, actual.types.items.len },
);
continue;
}
}
if (try checkExpectedErrors(&pp, &buf)) |some| {
if (some) ok_count += 1 else fail_count += 1;
continue;
}
if (pp.defines.contains("NO_ERROR_VALIDATION")) {
var m = MsgWriter.init(pp.comp.gpa);
defer m.deinit();
aro.Diagnostics.renderMessages(pp.comp, &m);
continue;
}
aro.Diagnostics.render(&comp, std.io.tty.detectConfig(std.io.getStdErr()));
if (pp.defines.get("EXPECTED_OUTPUT")) |macro| blk: {
if (comp.diagnostics.errors != 0) break :blk;
if (macro.is_func) {
fail_count += 1;
std.debug.print("invalid EXPECTED_OUTPUT {}\n", .{macro});
continue;
}
if (macro.tokens.len != 1 or macro.tokens[0].id != .string_literal) {
fail_count += 1;
std.debug.print("EXPECTED_OUTPUT takes exactly one string", .{});
continue;
}
defer buf.items.len = 0;
// realistically the strings will only contain \" if any escapes so we can use Zig's string parsing
std.debug.assert((try std.zig.string_literal.parseWrite(buf.writer(), pp.tokSlice(macro.tokens[0]))) == .success);
const expected_output = buf.items;
const obj_name = "test_object.o";
if (true) break :blk;
// {
// const obj = try Codegen.generateTree(&comp, tree);
// defer obj.deinit();
// const out_file = try std.fs.cwd().createFile(obj_name, .{});
// defer out_file.close();
// try obj.finish(out_file);
// }
var child = std.process.Child.init(&.{ args[2], "run", "-lc", obj_name }, gpa);
child.stdout_behavior = .Pipe;
try child.spawn();
const stdout = try child.stdout.?.reader().readAllAlloc(gpa, std.math.maxInt(u16));
defer gpa.free(stdout);
switch (try child.wait()) {
.Exited => |code| if (code != 0) {
fail_count += 1;
continue;
},
else => {
fail_count += 1;
continue;
},
}
if (!std.mem.eql(u8, expected_output, stdout)) {
fail_count += 1;
std.debug.print(
\\
\\======= expected output =======
\\{s}
\\
\\=== but output does not contain it ===
\\{s}
\\
\\
, .{ expected_output, stdout });
break;
}
ok_count += 1;
continue;
}
if (comp.diagnostics.errors != 0) fail_count += 1 else ok_count += 1;
}
root_node.end();
if (ok_count == cases.items.len and skip_count == 0) {
print("All {d} tests passed.\n", .{ok_count});
} else if (fail_count == 0) {
print("{d} passed; {d} skipped.\n", .{ ok_count, skip_count });
} else {
print("{d} passed; {d} failed.\n\n", .{ ok_count, fail_count });
std.process.exit(1);
}
}
// returns true if passed
fn checkExpectedErrors(pp: *aro.Preprocessor, buf: *std.ArrayList(u8)) !?bool {
const macro = pp.defines.get("EXPECTED_ERRORS") orelse return null;
const expected_count = pp.comp.diagnostics.list.items.len;
var m = MsgWriter.init(pp.comp.gpa);
defer m.deinit();
aro.Diagnostics.renderMessages(pp.comp, &m);
if (macro.is_func) {
std.debug.print("invalid EXPECTED_ERRORS {}\n", .{macro});
return false;
}
var count: usize = 0;
for (macro.tokens) |str| {
if (str.id == .macro_ws) continue;
if (str.id != .string_literal) {
std.debug.print("EXPECTED_ERRORS tokens must be string literals (found {s})\n", .{@tagName(str.id)});
return false;
}
defer count += 1;
if (count >= expected_count) continue;
defer buf.items.len = 0;
// realistically the strings will only contain \" if any escapes so we can use Zig's string parsing
std.debug.assert((try std.zig.string_literal.parseWrite(buf.writer(), pp.tokSlice(str))) == .success);
try buf.append('\n');
const expected_error = buf.items;
const index = std.mem.indexOf(u8, m.buf.items, expected_error);
if (index == null) {
std.debug.print(
\\
\\======= expected to find error =======
\\{s}
\\
\\=== but output does not contain it ===
\\{s}
\\
\\
, .{ expected_error, m.buf.items });
return false;
}
}
if (count != expected_count) {
std.debug.print(
\\EXPECTED_ERRORS missing errors, expected {d} found {d},
\\=== actual output ===
\\{s}
\\
\\
, .{ count, expected_count, m.buf.items });
return false;
}
return true;
}
const MsgWriter = struct {
buf: std.ArrayList(u8),
fn init(gpa: std.mem.Allocator) MsgWriter {
return .{
.buf = std.ArrayList(u8).init(gpa),
};
}
fn deinit(m: *MsgWriter) void {
m.buf.deinit();
}
pub fn print(m: *MsgWriter, comptime fmt: []const u8, args: anytype) void {
m.buf.writer().print(fmt, args) catch {};
}
pub fn write(m: *MsgWriter, msg: []const u8) void {
m.buf.writer().writeAll(msg) catch {};
}
pub fn location(m: *MsgWriter, path: []const u8, line: u32, col: u32) void {
m.print("{s}:{d}:{d}: ", .{ path, line, col });
}
pub fn start(m: *MsgWriter, kind: aro.Diagnostics.Kind) void {
m.print("{s}: ", .{@tagName(kind)});
}
pub fn end(m: *MsgWriter, maybe_line: ?[]const u8, col: u32, end_with_splice: bool) void {
const line = maybe_line orelse {
m.write("\n");
return;
};
const trailer = if (end_with_splice) "\\ " else "";
m.print("\n{s}{s}\n", .{ line, trailer });
m.print("{s: >[1]}^\n", .{ "", col });
}
};
const StmtTypeDumper = struct {
types: std.ArrayList([]const u8),
fn deinit(self: *StmtTypeDumper, allocator: std.mem.Allocator) void {
for (self.types.items) |t| {
allocator.free(t);
}
self.types.deinit();
}
fn init(allocator: std.mem.Allocator) StmtTypeDumper {
return .{
.types = std.ArrayList([]const u8).init(allocator),
};
}
fn dumpNode(self: *StmtTypeDumper, tree: *const aro.Tree, mapper: aro.TypeMapper, node: NodeIndex, m: *MsgWriter) AllocatorError!void {
if (node == .none) return;
const tag = tree.nodes.items(.tag)[@intFromEnum(node)];
if (tag == .implicit_return) return;
const ty = tree.nodes.items(.ty)[@intFromEnum(node)];
ty.dump(mapper, tree.comp.langopts, m.buf.writer()) catch {};
const owned = try m.buf.toOwnedSlice();
errdefer m.buf.allocator.free(owned);
try self.types.append(owned);
}
fn dump(self: *StmtTypeDumper, tree: *const aro.Tree, mapper: aro.TypeMapper, decl_idx: NodeIndex, allocator: std.mem.Allocator) AllocatorError!void {
var m = MsgWriter.init(allocator);
defer m.deinit();
const idx = @intFromEnum(decl_idx);
const tag = tree.nodes.items(.tag)[idx];
const data = tree.nodes.items(.data)[idx];
switch (tag) {
.compound_stmt_two => {
try self.dumpNode(tree, mapper, data.bin.lhs, &m);
try self.dumpNode(tree, mapper, data.bin.rhs, &m);
},
.compound_stmt => {
for (tree.data[data.range.start..data.range.end]) |stmt| {
try self.dumpNode(tree, mapper, stmt, &m);
}
},
else => unreachable,
}
}
};
|
0 | repos/arocc | repos/arocc/test/record_runner.zig | const std = @import("std");
const print = std.debug.print;
const aro = @import("aro");
/// These tests don't work for any platform due to Aro bugs.
/// Skip entirely.
/// To skip a test entirely just put the test name as a single-element tuple e.g. initComptime(.{.{"0044"}});
const global_test_exclude = std.StaticStringMap(void).initComptime(.{});
fn lessThan(_: void, lhs: []const u8, rhs: []const u8) bool {
return std.mem.lessThan(u8, lhs, rhs);
}
const MAX_MEM_PER_TEST = 1024 * 1024 * 16;
/// Set true to debug specific targets w/ specific tests.
const test_single_target = false;
const single_target = .{
// .target = "arm-cortex_r4-ios-none:Clang",
// .c_test = "0064",
// .target = "s390x-generic-linux-gnu:Gcc",
// .c_test = "00", // run all the tests
// .target = "x86-i586-linux-gnu:Gcc",
// .c_test = "0002",
.target = "x86_64-x86_64-windows-msvc:Msvc",
.c_test = "0018", // run all the tests
// .target = "arm-arm1136j_s-freebsd-gnu:Clang",
// .c_test = "0052",
};
const Stats = struct {
ok_count: u32 = 0,
fail_count: u32 = 0,
skip_count: u32 = 0,
invalid_target_count: u32 = 0,
max_alloc: usize = 0,
root_node: std.Progress.Node,
const ResultKind = enum {
ok,
fail,
skip,
invalid_target,
};
fn recordResult(self: *Stats, kind: ResultKind) void {
const ptr = switch (kind) {
.ok => &self.ok_count,
.fail => &self.fail_count,
.skip => &self.skip_count,
.invalid_target => &self.invalid_target_count,
};
_ = @atomicRmw(u32, ptr, .Add, 1, .monotonic);
}
fn updateMaxMemUsage(self: *Stats, bytes: usize) void {
_ = @atomicRmw(usize, &self.max_alloc, .Max, bytes, .monotonic);
}
};
const TestCase = struct {
c_define: []const u8,
target: []const u8,
path: []const u8,
source: []const u8,
const List = std.ArrayList(TestCase);
};
/// Types of failures expected.
/// For any given test. `true` = expected failure
const ExpectedFailure = struct {
parse: bool = false,
layout: bool = false,
extra: bool = false,
offset: bool = false,
fn any(self: ExpectedFailure) bool {
return self.parse or self.layout or self.extra or self.offset;
}
fn eql(self: ExpectedFailure, other: ExpectedFailure) bool {
return std.meta.eql(self, other);
}
};
const builtin = @import("builtin");
pub fn main() !void {
var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
const gpa = general_purpose_allocator.allocator();
defer if (general_purpose_allocator.deinit() == .leak) std.process.exit(1);
const args = try std.process.argsAlloc(gpa);
defer std.process.argsFree(gpa, args);
if (args.len != 2) {
print("expected test case directory as only argument\n", .{});
return error.InvalidArguments;
}
const test_dir = args[1];
var cases = std.ArrayList([]const u8).init(gpa);
defer {
for (cases.items) |path| gpa.free(path);
cases.deinit();
}
// Collect all cases. Set scope to clean when done.
{
var cases_dir = try std.fs.cwd().openDir(args[1], .{ .iterate = true });
defer cases_dir.close();
var buf: [1024]u8 = undefined;
var buf_strm = std.io.fixedBufferStream(&buf);
var it = cases_dir.iterate();
while (try it.next()) |entry| {
if (entry.kind == .directory) continue;
if (entry.kind != .file) {
print("skipping non file entry '{s}'\n", .{entry.name});
continue;
}
if (std.ascii.indexOfIgnoreCase(entry.name, "_test.c") != null) {
buf_strm.reset();
try buf_strm.writer().print("{s}{c}{s}", .{ args[1], std.fs.path.sep, entry.name });
try cases.append(try gpa.dupe(u8, buf[0..buf_strm.pos]));
}
}
}
std.mem.sort([]const u8, cases.items, {}, lessThan);
var arena_instance = std.heap.ArenaAllocator.init(gpa);
defer arena_instance.deinit();
const arena = arena_instance.allocator();
const thread_count = @max(1, std.Thread.getCpuCount() catch 1);
var thread_pool: std.Thread.Pool = undefined;
try thread_pool.init(.{ .allocator = arena, .n_jobs = @intCast(thread_count) });
defer thread_pool.deinit();
var wait_group: std.Thread.WaitGroup = .{};
var test_cases = TestCase.List.init(gpa);
defer test_cases.deinit();
for (cases.items) |path| {
const source = try std.fs.cwd().readFileAlloc(arena, path, std.math.maxInt(u32));
try parseTargetsFromCode(&test_cases, path, source);
}
const root_node = std.Progress.start(.{
.disable_printing = false,
.root_name = "Layout",
.estimated_total_items = test_cases.items.len,
});
var stats = Stats{
.root_node = root_node,
};
for (0..thread_count) |i| {
wait_group.start();
try thread_pool.spawn(runTestCases, .{
gpa, test_dir, &wait_group, test_cases.items[i..], thread_count, &stats,
});
}
thread_pool.waitAndWork(&wait_group);
root_node.end();
std.debug.print("max mem used = {:.2}\n", .{std.fmt.fmtIntSizeBin(stats.max_alloc)});
if (stats.ok_count == cases.items.len and stats.skip_count == 0) {
print("All {d} tests passed ({d} invalid targets)\n", .{ stats.ok_count, stats.invalid_target_count });
} else if (stats.fail_count == 0) {
print("{d} passed; {d} skipped ({d} invalid targets).\n", .{ stats.ok_count, stats.skip_count, stats.invalid_target_count });
} else {
print("{d} passed; {d} failed ({d} invalid targets).\n\n", .{ stats.ok_count, stats.fail_count, stats.invalid_target_count });
std.process.exit(1);
}
}
fn runTestCases(allocator: std.mem.Allocator, test_dir: []const u8, wg: *std.Thread.WaitGroup, test_cases: []const TestCase, stride: usize, stats: *Stats) void {
defer wg.finish();
const mem = allocator.alloc(u8, MAX_MEM_PER_TEST) catch |err| {
std.log.err("{s}", .{@errorName(err)});
if (@errorReturnTrace()) |trace| {
std.debug.dumpStackTrace(trace.*);
}
stats.recordResult(.fail);
return;
};
defer allocator.free(mem);
var fib = std.heap.FixedBufferAllocator.init(mem);
for (test_cases, 0..) |case, i| {
if (i % stride != 0) continue;
defer fib.end_index = 0;
singleRun(fib.allocator(), test_dir, case, stats) catch |err| {
std.log.err("{s}", .{@errorName(err)});
if (@errorReturnTrace()) |trace| {
std.debug.dumpStackTrace(trace.*);
}
stats.recordResult(.fail);
};
stats.updateMaxMemUsage(fib.end_index);
}
}
fn singleRun(alloc: std.mem.Allocator, test_dir: []const u8, test_case: TestCase, stats: *Stats) !void {
const path = test_case.path;
var comp = aro.Compilation.init(alloc, std.fs.cwd());
defer comp.deinit();
try comp.addDefaultPragmaHandlers();
try comp.addBuiltinIncludeDir(test_dir);
const target = setTarget(&comp, test_case.target) catch |err| switch (err) {
error.UnknownCpuModel => unreachable,
};
switch (target.os.tag) {
.hermit => {
stats.recordResult(.invalid_target);
return; // Skip targets Aro doesn't support.
},
else => {},
}
var case_name = std.ArrayList(u8).init(alloc);
defer case_name.deinit();
const test_name = std.mem.sliceTo(std.fs.path.basename(path), '_');
try case_name.writer().print("{s} | {s} | {s}", .{
test_name,
test_case.target,
test_case.c_define,
});
var case_node = stats.root_node.start(case_name.items, 0);
defer case_node.end();
const file = comp.addSourceFromBuffer(path, test_case.source) catch |err| {
stats.recordResult(.fail);
std.debug.print("could not add source '{s}': {s}\n", .{ path, @errorName(err) });
return;
};
var macro_buf = std.ArrayList(u8).init(comp.gpa);
defer macro_buf.deinit();
comp.langopts.setEmulatedCompiler(aro.target_util.systemCompiler(comp.target));
const mac_writer = macro_buf.writer();
try mac_writer.print("#define {s}\n", .{test_case.c_define});
if (comp.langopts.emulate == .msvc) {
comp.langopts.enableMSExtensions();
try mac_writer.writeAll("#define MSVC\n");
}
const user_macros = try comp.addSourceFromBuffer("<command line>", macro_buf.items);
const builtin_macros = try comp.generateBuiltinMacros(.include_system_defines);
var pp = aro.Preprocessor.init(&comp);
defer pp.deinit();
try pp.addBuiltinMacros();
_ = try pp.preprocess(builtin_macros);
_ = try pp.preprocess(user_macros);
const eof = pp.preprocess(file) catch |err| {
stats.recordResult(.fail);
std.debug.print("could not preprocess file '{s}': {s}\n", .{ path, @errorName(err) });
return;
};
try pp.addToken(eof);
var tree = try aro.Parser.parse(&pp);
defer tree.deinit();
tree.dump(.no_color, std.io.null_writer) catch {};
if (test_single_target) {
aro.Diagnostics.render(&comp, std.io.tty.detectConfig(std.io.getStdErr()));
return;
}
if (global_test_exclude.has(test_name)) {
stats.recordResult(.skip);
return;
}
var buf: [128]u8 = undefined;
var buf_strm = std.io.fixedBufferStream(&buf);
try buf_strm.writer().print("{s}|{s}", .{ test_case.target, test_name });
const expected = compErr.get(buf[0..buf_strm.pos]) orelse ExpectedFailure{};
if (comp.diagnostics.list.items.len == 0 and expected.any()) {
std.debug.print("\nTest Passed when failures expected:\n\texpected:{any}\n", .{expected});
} else {
var m = aro.Diagnostics.defaultMsgWriter(std.io.tty.detectConfig(std.io.getStdErr()));
defer m.deinit();
var actual = ExpectedFailure{};
for (comp.diagnostics.list.items) |msg| {
switch (msg.kind) {
.@"fatal error", .@"error" => {},
else => continue,
}
const src = comp.getSource(msg.loc.id);
const line = src.lineCol(msg.loc).line;
if (std.ascii.indexOfIgnoreCase(line, "_Static_assert") != null) {
if (std.ascii.indexOfIgnoreCase(line, "_extra_") != null) {
actual.extra = true;
} else if (std.ascii.indexOfIgnoreCase(line, "_bitoffsetof") != null) {
actual.offset = true;
} else if (std.ascii.indexOfIgnoreCase(line, "sizeof") != null or
std.ascii.indexOfIgnoreCase(line, "_alignof") != null)
{
actual.layout = true;
} else unreachable;
} else {
actual.parse = true;
}
}
if (!expected.eql(actual)) {
m.print("\nexp:{any}\nact:{any}\n", .{ expected, actual });
for (comp.diagnostics.list.items) |msg| {
aro.Diagnostics.renderMessage(&comp, &m, msg);
}
stats.recordResult(.fail);
} else if (actual.any()) {
stats.recordResult(.skip);
} else {
stats.recordResult(.ok);
}
}
}
/// Get Zig std.Target from string in the arch-cpu-os-abi format.
fn getTarget(zig_target_string: []const u8) !std.Target {
var ret: std.Target = undefined;
var iter = std.mem.tokenizeScalar(u8, zig_target_string, '-');
ret.cpu.arch = std.meta.stringToEnum(std.Target.Cpu.Arch, iter.next().?).?;
ret.cpu.model = try std.Target.Cpu.Arch.parseCpuModel(ret.cpu.arch, iter.next().?);
const tag = std.meta.stringToEnum(std.Target.Os.Tag, iter.next().?).?;
// `defaultVersionRange` will panic for invalid targets, check that
// here and set it to a reasonable default instead
var os: ?std.Target.Os = null;
if (tag == .macos) {
switch (ret.cpu.arch) {
.x86_64, .aarch64 => {},
else => os = .{ .version_range = .{ .none = {} }, .tag = .macos },
}
}
ret.os = os orelse std.Target.Os.Tag.defaultVersionRange(tag, ret.cpu.arch);
ret.abi = std.meta.stringToEnum(std.Target.Abi, iter.next().?).?;
return ret;
}
fn setTarget(comp: *aro.Compilation, target: []const u8) !std.Target {
const compiler_split_index = std.mem.indexOf(u8, target, ":").?;
const zig_target = try getTarget(target[0..compiler_split_index]);
comp.target.cpu = std.Target.Cpu.Model.toCpu(zig_target.cpu.model, zig_target.cpu.arch);
comp.target.os.tag = zig_target.os.tag;
comp.target.os.version_range = zig_target.os.version_range;
comp.target.abi = zig_target.abi;
comp.langopts.emulate = aro.target_util.systemCompiler(comp.target);
const expected_compiler_name = target[compiler_split_index + 1 ..];
const set_name = @tagName(comp.langopts.emulate);
std.debug.assert(std.ascii.eqlIgnoreCase(set_name, expected_compiler_name));
return zig_target;
}
fn parseTargetsFromCode(cases: *TestCase.List, path: []const u8, source: []const u8) !void {
var lines = std.mem.tokenizeScalar(u8, source, '\n');
while (lines.next()) |line| {
if (std.mem.indexOf(u8, line, "// MAPPING|") == null) continue;
std.debug.assert(std.mem.count(u8, line, "|") > 1);
var parts = std.mem.tokenizeScalar(u8, line, '|');
_ = parts.next(); // Skip the MAPPING bit
const define = parts.next().?; // The define to set for this chunk.
while (parts.next()) |target| {
if (std.mem.startsWith(u8, target, "END")) break;
// These point to source, which lives
// for the life of the test. So should be ok
try cases.append(.{
.path = path,
.source = source,
.c_define = define,
.target = target,
});
}
}
}
const compErr = blk: {
@setEvalBranchQuota(100_000);
break :blk std.StaticStringMap(ExpectedFailure).initComptime(.{
.{
"aarch64-generic-windows-msvc:Msvc|0011",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0014",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0018",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0020",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"aarch64-generic-windows-msvc:Msvc|0020",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"aarch64-generic-windows-msvc:Msvc|0021",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"aarch64-generic-windows-msvc:Msvc|0023",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0025",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0026",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0029",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0037",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0039",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0042",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"aarch64-generic-windows-msvc:Msvc|0044",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0045",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0046",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0053",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0063",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0065",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0066",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0072",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"aarch64-generic-windows-msvc:Msvc|0080",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0011",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0014",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0018",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0023",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0025",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0026",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0029",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0042",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"x86-i586-windows-msvc:Msvc|0044",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0045",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0046",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0053",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0063",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0065",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i586-windows-msvc:Msvc|0066",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0011",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0014",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0018",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0023",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0025",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0026",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0029",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0042",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"x86-i686-uefi-msvc:Msvc|0044",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0045",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0046",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0053",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0063",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0065",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-uefi-msvc:Msvc|0066",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0011",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0014",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0018",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0023",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0025",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0026",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0029",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0042",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"x86-i686-windows-msvc:Msvc|0044",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0045",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0046",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0053",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0063",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0065",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86-i686-windows-msvc:Msvc|0066",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0011",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0014",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0018",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0020",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"thumb-baseline-windows-msvc:Msvc|0021",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"thumb-baseline-windows-msvc:Msvc|0023",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0025",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0026",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0029",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0037",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0039",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0042",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"thumb-baseline-windows-msvc:Msvc|0044",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0045",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0046",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0053",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0063",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0065",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0066",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0072",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"thumb-baseline-windows-msvc:Msvc|0080",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0011",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0014",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0018",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0023",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0025",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0026",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0029",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0042",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0044",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0045",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0046",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0053",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0063",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0065",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-uefi-msvc:Msvc|0066",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0011",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0014",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0018",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0023",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0025",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0026",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0029",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0042",
.{ .parse = false, .layout = true, .extra = true, .offset = true },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0044",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0045",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0046",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0053",
.{ .parse = false, .layout = false, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0063",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0065",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
.{
"x86_64-x86_64-windows-msvc:Msvc|0066",
.{ .parse = false, .layout = true, .extra = true, .offset = false },
},
});
};
|
0 | repos/arocc | repos/arocc/test/record_readme.md |
# Record test files and test runner.
The `.c` files in `test/records` test arocc's memory layout of struts and unions. `record_runner.zig` setups and runs each test for each target.
# Overview of `.c` test files
All the record tests are in the directory `/test/records/` and have a filename of `00XX_test.c` where `XX` is between 01 and 88.
These `.c` files are auto-generated. They come from the GitHub repro at https://github.com/mahkoh/repr-c. The repr-c project keeps the records and expected results in "cooked" format. The code to generate the `.c` files can be found on this fork https://github.com/TwoClocks/repr-c/tree/arocc-test-gen in the `/repr/arocc` directory.
### License
The repr-c project test data is under GPLv3 license. Since these `_test.c` file are a derivative work, they are under the same license. There is a license SPDX at the top of each file. Because these files are not compiled into arocc, they do not affect arocc's license, and via versa.
# `XXXX_test.c` file layout
A brief tour of the test file. First there is a record to be tested. The define `MSVC` controls if you want to use the GCC or Microsoft extensions. If not set, GCC is used.
```c
typedef struct {
char c:1;
int:0;
char d;
} A;
A var1;
```
Then there will be 4 algorithmic versions of the record being used
```c
struct A_alignment {
#ifdef MSVC
char a[_Alignof(A)];
char b;
#else
char a;
A b;
#endif
};
struct A_alignment var2;
#pragma pack(1)
struct A_packed {
A a;
};
#pragma pack()
struct A_required_alignment {
#ifdef MSVC
char a[_Alignof(struct A_packed)];
char b;
#else
char a;
struct A_packed b;
#endif
};
struct A_required_alignment var3;
struct A_size {
char a[sizeof(A)+1];
char b;
};
struct A_size var4;
```
Next are the asserts that test the layout. They are grouped by a unique layout. Set the define `ONE` to run the asserts for this group. Groups are always the English words between one and eighteen. They are mutually exclusive.
```c
#ifdef ONE
_Static_assert(sizeof(X) == 24, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 24, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 26, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 128, "");
#endif
#elif defined(TWO
...
```
Basic `sizeof`, `alignof` and "extra" checks are done in each group. Starting offsets are checked for records that have more than one member. As `__builtin_bitoffsetof` is not standard, can can be skipped by defining `SKIP_OFFSET`. Use this if compiling with GCC or Clang.
Before each grouping of asserts, there is a comment describing which targets a group is intended for.
```c
...
#endif
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc")
#elif defined(THREE)
_Static_assert(sizeof(A) == 8, "");
...
```
The first comment is machine-readable. 'MAPPING' is a marker for a new group starting. It's followed by the English number for the group (same as used for the follow define check). Then there is a list of targets w/ expected compiler. These targets are not in llvm-tripet/zig/rust form. There are always 4 parts separated by `-`. They directly map to the `std.Target` enums in zig. The format is `Arch-CpuModel-Os.Tag-Abi`. The target is followed by `:Compiler` where compiler is one of `Gcc`, `Clang`, or `Msvc`. The line always ends with the `END` sentinel.
The second comment is a mapping back to the targets from the repr-c project. This is informational only. The code to map between reprc->Rust->Zig targets is in the repr-c branch in the same directly as the C generation code. It is likely not 100% accurate, so this comment is here to help find errors.
# The test runner
`record_runner.zig` gets a list of files in the `records/` directory ending with `_test.c` It then parses out the define groups, and which targets map to which group. It then invokes arocc once for every target listed, setting the appropriate define for each target.
There are numerous bugs in arocc and zig that prevent all targets working. You can see a current list of issues here : https://github.com/Vexu/arocc/issues/387.
There are some issues that cause a test file to fail for all targets. These are marked at the top of the file.
Other targets only fail on certain tests. At the bottom of the file there is a listing of which targets fail for which tests.
There is also a static structure `do_single` at the top of the file that will run just one test for a specific target, or all tests for a specific target. Helpful for debugging specific issues. It is `null` by default.
Generally, x86_64 and aarch64 SystemV-like targets (linux, freebsd, macos, etc) will mimic GCC/clang layout, including correct bitfield layout. The major exception when an annotation that affects layout is on a `typedef` (see #332).
|
0 | repos/arocc/test | repos/arocc/test/records/0048_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c;
#ifdef MSVC
__declspec(align(128)) int:0;
#else
int:0 __attribute__((aligned(128)));
#endif
} X;
X var1;
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var2;
#pragma pack(1)
struct X_extra_packed {
#ifdef MSVC
char a[sizeof(X)];
#else
X a;
#endif
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var3;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var4;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(X) == 128, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 129, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 128, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 130, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(X) == 128, "");
_Static_assert(_Alignof(X) == 128, "");
_Static_assert(sizeof(struct X_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 128, "");
_Static_assert(sizeof(struct X_extra_packed) == 128, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 130, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(THREE)
_Static_assert(sizeof(X) == 1, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 3, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(X) == 128, "");
_Static_assert(_Alignof(X) == 128, "");
_Static_assert(sizeof(struct X_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 128, "");
_Static_assert(sizeof(struct X_extra_packed) == 128, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 130, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(X) == 128, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 129, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 128, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 130, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0079_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c;
int i:1 __attribute__((aligned(2)));
char d;
} __attribute__((packed)) A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
A a;
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
char c;
int i:1 __attribute__((aligned(2))) __attribute__((packed));
char d;
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
B a;
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
typedef union {
char c;
int i:1 __attribute__((aligned(2)));
char d;
} __attribute__((packed)) C;
C var9;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
C a;
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
typedef union {
char c;
int i:1 __attribute__((aligned(2))) __attribute__((packed));
char d;
} D;
D var13;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var14;
#pragma pack(1)
struct D_extra_packed {
D a;
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var15;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var16;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,i) == 16, "");
_Static_assert(__builtin_bitoffsetof(A,d) == 24, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,i) == 16, "");
_Static_assert(__builtin_bitoffsetof(B,d) == 24, "");
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,i) == 0, "");
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,i) == 0, "");
_Static_assert(__builtin_bitoffsetof(D,d) == 0, "");
#endif
// MAPPING|TWO|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,i) == 16, "");
_Static_assert(__builtin_bitoffsetof(A,d) == 24, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,i) == 16, "");
_Static_assert(__builtin_bitoffsetof(B,d) == 24, "");
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,i) == 0, "");
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,i) == 0, "");
_Static_assert(__builtin_bitoffsetof(D,d) == 0, "");
#endif
// MAPPING|THREE|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(THREE)
_Static_assert(sizeof(A) == 7, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 7, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 9, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,i) == 16, "");
_Static_assert(__builtin_bitoffsetof(A,d) == 48, "");
#endif
_Static_assert(sizeof(B) == 7, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 7, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 9, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,i) == 16, "");
_Static_assert(__builtin_bitoffsetof(B,d) == 48, "");
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,i) == 0, "");
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,i) == 0, "");
_Static_assert(__builtin_bitoffsetof(D,d) == 0, "");
#endif
// MAPPING|FOUR|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,i) == 16, "");
_Static_assert(__builtin_bitoffsetof(A,d) == 24, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,i) == 16, "");
_Static_assert(__builtin_bitoffsetof(B,d) == 24, "");
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,i) == 0, "");
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,i) == 0, "");
_Static_assert(__builtin_bitoffsetof(D,d) == 0, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0070_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef int A __attribute__((aligned(1)));
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
A a;
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef union {
A a:1;
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
B a;
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
typedef union {
int a:1 __attribute__((packed));
} C;
C var9;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
C a;
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
#pragma pack(1)
typedef union {
int a:1;
} D;
D var13;
#pragma pack()
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var14;
#pragma pack(1)
struct D_extra_packed {
D a;
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var15;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var16;
typedef union {
A a:9;
} E;
E var17;
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var18;
#pragma pack(1)
struct E_extra_packed {
E a;
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var19;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var20;
typedef union {
int a:9 __attribute__((packed));
} F;
F var21;
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var22;
#pragma pack(1)
struct F_extra_packed {
F a;
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var23;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var24;
#pragma pack(1)
typedef union {
int a:9;
} G;
G var25;
#pragma pack()
struct G_extra_alignment {
char a;
G b;
};
struct G_extra_alignment var26;
#pragma pack(1)
struct G_extra_packed {
G a;
};
#pragma pack()
struct G_extra_required_alignment {
char a;
struct G_extra_packed b;
};
struct G_extra_required_alignment var27;
struct G_extra_size {
char a[sizeof(G)+1];
char b;
};
struct G_extra_size var28;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 2, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 2, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 4, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 2, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 2, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 4, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
// MAPPING|TWO|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 2, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 2, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 4, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 2, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 2, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 4, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
// MAPPING|THREE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 2, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 2, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 4, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 2, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 2, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 4, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0039_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c:1;
int:0;
char d;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
char c:1;
int:0;
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
typedef struct {
char c:1;
#ifdef MSVC
__declspec(align(128)) int:0;
#else
int:0 __attribute__((aligned(128)));
#endif
char d;
} C;
C var9;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 5, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 7, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 129, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 129, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 131, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 1024, "");
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|x86-i586-windows-msvc:Msvc|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 256, "");
_Static_assert(_Alignof(C) == 128, "");
_Static_assert(sizeof(struct C_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C_extra_packed) == 256, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 258, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 1024, "");
#endif
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc")
#elif defined(THREE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 136, "");
_Static_assert(_Alignof(C) == 128, "");
_Static_assert(sizeof(struct C_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C_extra_packed) == 136, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 137, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 138, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 1024, "");
#endif
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 8, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 256, "");
_Static_assert(_Alignof(C) == 128, "");
_Static_assert(sizeof(struct C_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C_extra_packed) == 256, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 258, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 1024, "");
#endif
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 3, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 5, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 16, "");
#endif
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 129, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 129, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 131, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 1024, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0061_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(1)
typedef enum {
F1 = 1,
} A;
A var2;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var3;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var4;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var5;
#pragma pack(1)
typedef enum {
F6 = 1111,
} B;
B var7;
#pragma pack()
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var8;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var9;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var10;
#pragma pack(1)
typedef enum {
F11 = 18764712120593,
} C;
C var12;
#pragma pack()
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var13;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var14;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var15;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|x86-i686-windows-gnu:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") I686PcWindowsGnu|Some("x86-i686-windows-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(THREE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
// MAPPING|FIVE|hexagon-generic-linux-musl:Clang|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0057_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(2)
typedef struct {
char c;
int i __attribute__((packed));
} A;
A var1;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
#ifdef MSVC
__declspec(align(8)) int i:1;
#else
int i:1 __attribute__((aligned(8)));
#endif
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
#pragma pack(2)
typedef struct {
char c;
B b __attribute__((packed));
} C;
C var9;
#pragma pack()
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
typedef struct {
char c;
int i __attribute__((packed));
} D;
D var13;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var14;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var15;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var16;
typedef struct {
#ifdef MSVC
__declspec(align(8)) int i:1;
#else
int i:1 __attribute__((aligned(8)));
#endif
} E;
E var17;
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var18;
#pragma pack(1)
struct E_extra_packed {
#ifdef MSVC
char a[sizeof(E)];
#else
E a;
#endif
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var19;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var20;
typedef struct {
char c;
E b __attribute__((packed));
} F;
F var21;
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var22;
#pragma pack(1)
struct F_extra_packed {
#ifdef MSVC
char a[sizeof(F)];
#else
F a;
#endif
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var23;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var24;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-windows-msvc:Msvc|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-windows-msvc:Msvc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|x86-i686-uefi-msvc:Msvc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-baseline-windows-msvc:Msvc|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") I686UnknownWindows|Some("x86-i686-uefi-msvc") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#ifdef ONE
_Static_assert(sizeof(A) == 5, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 7, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,i) == 8, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 9, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 9, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 11, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 8, "");
#endif
_Static_assert(sizeof(D) == 5, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 5, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 7, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,i) == 8, "");
#endif
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 9, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 9, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 11, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,b) == 8, "");
#endif
// MAPPING|TWO|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 3, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 5, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,i) == 8, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 9, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 9, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 11, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 8, "");
#endif
_Static_assert(sizeof(D) == 3, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 3, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 5, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,i) == 8, "");
#endif
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 9, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 9, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 11, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,b) == 8, "");
#endif
// MAPPING|THREE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 3, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 5, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,i) == 8, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 9, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 9, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 11, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 8, "");
#endif
_Static_assert(sizeof(D) == 3, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 3, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 5, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,i) == 8, "");
#endif
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 9, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 9, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 11, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,b) == 8, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0074_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c:1;
char:0;
char d:1;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef union {
char c:1;
char:0;
char d:1;
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-windows-msvc:Msvc|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|avr-avr2-other-eabi:Gcc|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-windows-msvc:Msvc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|x86-i686-uefi-msvc:Msvc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|msp430-msp430-other-eabi:Clang|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-baseline-windows-msvc:Msvc|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") AvrUnknownUnknown|Some("avr-avr2-other-eabi") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") I686UnknownWindows|Some("x86-i686-uefi-msvc") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Msp430NoneElf|Some("msp430-msp430-other-eabi") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#ifdef ONE
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 8, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
// MAPPING|TWO|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(TWO)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0011_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(8)) typedef int I1;
#else
typedef int I1 __attribute__((aligned(8)));
#endif
I1 var1;
struct I1_extra_alignment {
char a;
I1 b;
};
struct I1_extra_alignment var2;
#pragma pack(1)
struct I1_extra_packed {
#ifdef MSVC
char a[sizeof(I1)];
#else
I1 a;
#endif
};
#pragma pack()
struct I1_extra_required_alignment {
char a;
struct I1_extra_packed b;
};
struct I1_extra_required_alignment var3;
struct I1_extra_size {
char a[sizeof(I1)+1];
char b;
};
struct I1_extra_size var4;
#ifdef MSVC
__declspec(align(1)) typedef I1 I2;
#else
typedef I1 I2 __attribute__((aligned(1)));
#endif
I2 var5;
struct I2_extra_alignment {
char a;
I2 b;
};
struct I2_extra_alignment var6;
#pragma pack(1)
struct I2_extra_packed {
#ifdef MSVC
char a[sizeof(I2)];
#else
I2 a;
#endif
};
#pragma pack()
struct I2_extra_required_alignment {
char a;
struct I2_extra_packed b;
};
struct I2_extra_required_alignment var7;
struct I2_extra_size {
char a[sizeof(I2)+1];
char b;
};
struct I2_extra_size var8;
typedef struct {
I2 i;
} X;
X var9;
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var10;
#pragma pack(1)
struct X_extra_packed {
#ifdef MSVC
char a[sizeof(X)];
#else
X a;
#endif
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var11;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var12;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(I1) == 4, "");
_Static_assert(_Alignof(I1) == 8, "");
_Static_assert(sizeof(struct I1_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct I1_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I1_extra_packed) == 1, "");
_Static_assert(sizeof(struct I1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I1_extra_size) == 6, "");
_Static_assert(_Alignof(struct I1_extra_size) == 1, "");
_Static_assert(sizeof(I2) == 4, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 6, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
_Static_assert(sizeof(X) == 4, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 4, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 6, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(I1) == 4, "");
_Static_assert(_Alignof(I1) == 8, "");
_Static_assert(sizeof(struct I1_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct I1_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I1_extra_packed) == 1, "");
_Static_assert(sizeof(struct I1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I1_extra_size) == 6, "");
_Static_assert(_Alignof(struct I1_extra_size) == 1, "");
_Static_assert(sizeof(I2) == 4, "");
_Static_assert(_Alignof(I2) == 8, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 6, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
_Static_assert(sizeof(X) == 8, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 8, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 10, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(I1) == 2, "");
_Static_assert(_Alignof(I1) == 8, "");
_Static_assert(sizeof(struct I1_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct I1_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I1_extra_packed) == 2, "");
_Static_assert(_Alignof(struct I1_extra_packed) == 1, "");
_Static_assert(sizeof(struct I1_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct I1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I1_extra_size) == 4, "");
_Static_assert(_Alignof(struct I1_extra_size) == 1, "");
_Static_assert(sizeof(I2) == 2, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 4, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
_Static_assert(sizeof(X) == 2, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 2, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 4, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
// MAPPING|FOUR|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(I1) == 2, "");
_Static_assert(_Alignof(I1) == 8, "");
_Static_assert(sizeof(struct I1_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct I1_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I1_extra_packed) == 2, "");
_Static_assert(_Alignof(struct I1_extra_packed) == 1, "");
_Static_assert(sizeof(struct I1_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct I1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I1_extra_size) == 4, "");
_Static_assert(_Alignof(struct I1_extra_size) == 1, "");
_Static_assert(sizeof(I2) == 2, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 4, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
_Static_assert(sizeof(X) == 2, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 2, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 4, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0020_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
#ifdef MSVC
__declspec(align(128)) int i:1;
#else
int i:1 __attribute__((aligned(128)));
#endif
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
char c;
A a;
} A_;
A_ var5;
struct A__extra_alignment {
char a;
A_ b;
};
struct A__extra_alignment var6;
#pragma pack(1)
struct A__extra_packed {
#ifdef MSVC
char a[sizeof(A_)];
#else
A_ a;
#endif
};
#pragma pack()
struct A__extra_required_alignment {
char a;
struct A__extra_packed b;
};
struct A__extra_required_alignment var7;
struct A__extra_size {
char a[sizeof(A_)+1];
char b;
};
struct A__extra_size var8;
typedef struct {
A a;
} B;
B var9;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var10;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var11;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var12;
#pragma pack(4)
typedef struct {
A a;
} C;
C var13;
#pragma pack()
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var14;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var15;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var16;
#pragma pack(8)
typedef struct {
A a;
} D;
D var17;
#pragma pack()
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var18;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var19;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var20;
#pragma pack(16)
typedef struct {
A a;
} E;
E var21;
#pragma pack()
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var22;
#pragma pack(1)
struct E_extra_packed {
#ifdef MSVC
char a[sizeof(E)];
#else
E a;
#endif
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var23;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var24;
#pragma pack(32)
typedef struct {
A a;
} F;
F var25;
#pragma pack()
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var26;
#pragma pack(1)
struct F_extra_packed {
#ifdef MSVC
char a[sizeof(F)];
#else
F a;
#endif
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var27;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var28;
typedef union {
A a;
} G;
G var29;
struct G_extra_alignment {
char a;
G b;
};
struct G_extra_alignment var30;
#pragma pack(1)
struct G_extra_packed {
#ifdef MSVC
char a[sizeof(G)];
#else
G a;
#endif
};
#pragma pack()
struct G_extra_required_alignment {
char a;
struct G_extra_packed b;
};
struct G_extra_required_alignment var31;
struct G_extra_size {
char a[sizeof(G)+1];
char b;
};
struct G_extra_size var32;
#pragma pack(4)
typedef union {
A a;
} H;
H var33;
#pragma pack()
struct H_extra_alignment {
char a;
H b;
};
struct H_extra_alignment var34;
#pragma pack(1)
struct H_extra_packed {
#ifdef MSVC
char a[sizeof(H)];
#else
H a;
#endif
};
#pragma pack()
struct H_extra_required_alignment {
char a;
struct H_extra_packed b;
};
struct H_extra_required_alignment var35;
struct H_extra_size {
char a[sizeof(H)+1];
char b;
};
struct H_extra_size var36;
#pragma pack(8)
typedef union {
A a;
} I;
I var37;
#pragma pack()
struct I_extra_alignment {
char a;
I b;
};
struct I_extra_alignment var38;
#pragma pack(1)
struct I_extra_packed {
#ifdef MSVC
char a[sizeof(I)];
#else
I a;
#endif
};
#pragma pack()
struct I_extra_required_alignment {
char a;
struct I_extra_packed b;
};
struct I_extra_required_alignment var39;
struct I_extra_size {
char a[sizeof(I)+1];
char b;
};
struct I_extra_size var40;
#pragma pack(16)
typedef union {
A a;
} J;
J var41;
#pragma pack()
struct J_extra_alignment {
char a;
J b;
};
struct J_extra_alignment var42;
#pragma pack(1)
struct J_extra_packed {
#ifdef MSVC
char a[sizeof(J)];
#else
J a;
#endif
};
#pragma pack()
struct J_extra_required_alignment {
char a;
struct J_extra_packed b;
};
struct J_extra_required_alignment var43;
struct J_extra_size {
char a[sizeof(J)+1];
char b;
};
struct J_extra_size var44;
#pragma pack(32)
typedef union {
A a;
} K;
K var45;
#pragma pack()
struct K_extra_alignment {
char a;
K b;
};
struct K_extra_alignment var46;
#pragma pack(1)
struct K_extra_packed {
#ifdef MSVC
char a[sizeof(K)];
#else
K a;
#endif
};
#pragma pack()
struct K_extra_required_alignment {
char a;
struct K_extra_packed b;
};
struct K_extra_required_alignment var47;
struct K_extra_size {
char a[sizeof(K)+1];
char b;
};
struct K_extra_size var48;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 128, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 130, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(A_) == 256, "");
_Static_assert(_Alignof(A_) == 128, "");
_Static_assert(sizeof(struct A__extra_alignment) == 384, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 128, "");
_Static_assert(sizeof(struct A__extra_packed) == 256, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 258, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,a) == 1024, "");
#endif
_Static_assert(sizeof(B) == 128, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 130, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 128, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 130, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 128, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 136, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 128, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 130, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 128, "");
_Static_assert(_Alignof(E) == 16, "");
_Static_assert(sizeof(struct E_extra_alignment) == 144, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 16, "");
_Static_assert(sizeof(struct E_extra_packed) == 128, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 130, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 128, "");
_Static_assert(_Alignof(F) == 128, "");
_Static_assert(sizeof(struct F_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 128, "");
_Static_assert(sizeof(struct F_extra_packed) == 128, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 130, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 128, "");
_Static_assert(_Alignof(G) == 128, "");
_Static_assert(sizeof(struct G_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 128, "");
_Static_assert(sizeof(struct G_extra_packed) == 128, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 130, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 128, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 128, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 130, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 128, "");
_Static_assert(_Alignof(I) == 8, "");
_Static_assert(sizeof(struct I_extra_alignment) == 136, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I_extra_packed) == 128, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 130, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 128, "");
_Static_assert(_Alignof(J) == 16, "");
_Static_assert(sizeof(struct J_extra_alignment) == 144, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 16, "");
_Static_assert(sizeof(struct J_extra_packed) == 128, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 130, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 128, "");
_Static_assert(_Alignof(K) == 128, "");
_Static_assert(sizeof(struct K_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 128, "");
_Static_assert(sizeof(struct K_extra_packed) == 128, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 130, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(A_) == 16, "");
_Static_assert(_Alignof(A_) == 8, "");
_Static_assert(sizeof(struct A__extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 8, "");
_Static_assert(sizeof(struct A__extra_packed) == 16, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 18, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,a) == 64, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 128, "");
_Static_assert(_Alignof(E) == 128, "");
_Static_assert(sizeof(struct E_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 128, "");
_Static_assert(sizeof(struct E_extra_packed) == 128, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 130, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 8, "");
_Static_assert(sizeof(struct F_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 8, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 8, "");
_Static_assert(_Alignof(G) == 8, "");
_Static_assert(sizeof(struct G_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 8, "");
_Static_assert(sizeof(struct G_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 10, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 8, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 10, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 8, "");
_Static_assert(_Alignof(I) == 8, "");
_Static_assert(sizeof(struct I_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 10, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 128, "");
_Static_assert(_Alignof(J) == 128, "");
_Static_assert(sizeof(struct J_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 128, "");
_Static_assert(sizeof(struct J_extra_packed) == 128, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 130, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 128, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 130, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(A_) == 256, "");
_Static_assert(_Alignof(A_) == 128, "");
_Static_assert(sizeof(struct A__extra_alignment) == 384, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 128, "");
_Static_assert(sizeof(struct A__extra_packed) == 256, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 258, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,a) == 1024, "");
#endif
_Static_assert(sizeof(B) == 128, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 130, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 128, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 130, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 128, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 136, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 128, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 130, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 128, "");
_Static_assert(_Alignof(E) == 16, "");
_Static_assert(sizeof(struct E_extra_alignment) == 144, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 16, "");
_Static_assert(sizeof(struct E_extra_packed) == 128, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 130, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 128, "");
_Static_assert(_Alignof(F) == 128, "");
_Static_assert(sizeof(struct F_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 128, "");
_Static_assert(sizeof(struct F_extra_packed) == 128, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 130, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 128, "");
_Static_assert(_Alignof(G) == 128, "");
_Static_assert(sizeof(struct G_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 128, "");
_Static_assert(sizeof(struct G_extra_packed) == 128, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 130, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 128, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 128, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 130, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 128, "");
_Static_assert(_Alignof(I) == 8, "");
_Static_assert(sizeof(struct I_extra_alignment) == 136, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I_extra_packed) == 128, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 130, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 128, "");
_Static_assert(_Alignof(J) == 16, "");
_Static_assert(sizeof(struct J_extra_alignment) == 144, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 16, "");
_Static_assert(sizeof(struct J_extra_packed) == 128, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 130, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 128, "");
_Static_assert(_Alignof(K) == 128, "");
_Static_assert(sizeof(struct K_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 128, "");
_Static_assert(sizeof(struct K_extra_packed) == 128, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 130, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
// MAPPING|FOUR|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|END
// repr targets I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 128, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 130, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(A_) == 256, "");
_Static_assert(_Alignof(A_) == 128, "");
_Static_assert(sizeof(struct A__extra_alignment) == 384, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 128, "");
_Static_assert(sizeof(struct A__extra_packed) == 256, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 258, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,a) == 1024, "");
#endif
_Static_assert(sizeof(B) == 128, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 130, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 128, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 130, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 128, "");
_Static_assert(_Alignof(D) == 128, "");
_Static_assert(sizeof(struct D_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 128, "");
_Static_assert(sizeof(struct D_extra_packed) == 128, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 130, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 128, "");
_Static_assert(_Alignof(E) == 128, "");
_Static_assert(sizeof(struct E_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 128, "");
_Static_assert(sizeof(struct E_extra_packed) == 128, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 130, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 128, "");
_Static_assert(_Alignof(F) == 128, "");
_Static_assert(sizeof(struct F_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 128, "");
_Static_assert(sizeof(struct F_extra_packed) == 128, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 130, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 128, "");
_Static_assert(_Alignof(G) == 128, "");
_Static_assert(sizeof(struct G_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 128, "");
_Static_assert(sizeof(struct G_extra_packed) == 128, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 130, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 128, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 128, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 130, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 128, "");
_Static_assert(_Alignof(I) == 128, "");
_Static_assert(sizeof(struct I_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 128, "");
_Static_assert(sizeof(struct I_extra_packed) == 128, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 130, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 128, "");
_Static_assert(_Alignof(J) == 128, "");
_Static_assert(sizeof(struct J_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 128, "");
_Static_assert(sizeof(struct J_extra_packed) == 128, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 130, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 128, "");
_Static_assert(_Alignof(K) == 128, "");
_Static_assert(sizeof(struct K_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 128, "");
_Static_assert(sizeof(struct K_extra_packed) == 128, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 130, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 128, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 130, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(A_) == 256, "");
_Static_assert(_Alignof(A_) == 128, "");
_Static_assert(sizeof(struct A__extra_alignment) == 384, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 128, "");
_Static_assert(sizeof(struct A__extra_packed) == 256, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 258, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,a) == 1024, "");
#endif
_Static_assert(sizeof(B) == 128, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 130, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 128, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 130, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 128, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 136, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 128, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 130, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 128, "");
_Static_assert(_Alignof(E) == 16, "");
_Static_assert(sizeof(struct E_extra_alignment) == 144, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 16, "");
_Static_assert(sizeof(struct E_extra_packed) == 128, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 130, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 128, "");
_Static_assert(_Alignof(F) == 128, "");
_Static_assert(sizeof(struct F_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 128, "");
_Static_assert(sizeof(struct F_extra_packed) == 128, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 130, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 128, "");
_Static_assert(_Alignof(G) == 128, "");
_Static_assert(sizeof(struct G_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 128, "");
_Static_assert(sizeof(struct G_extra_packed) == 128, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 130, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 128, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 128, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 130, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 128, "");
_Static_assert(_Alignof(I) == 8, "");
_Static_assert(sizeof(struct I_extra_alignment) == 136, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I_extra_packed) == 128, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 130, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 128, "");
_Static_assert(_Alignof(J) == 16, "");
_Static_assert(sizeof(struct J_extra_alignment) == 144, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 16, "");
_Static_assert(sizeof(struct J_extra_packed) == 128, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 130, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 128, "");
_Static_assert(_Alignof(K) == 128, "");
_Static_assert(sizeof(struct K_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 128, "");
_Static_assert(sizeof(struct K_extra_packed) == 128, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 130, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
// MAPPING|SIX|thumb-baseline-windows-msvc:Msvc|END
// repr targets Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc")
#elif defined(SIX)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(A_) == 16, "");
_Static_assert(_Alignof(A_) == 8, "");
_Static_assert(sizeof(struct A__extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 8, "");
_Static_assert(sizeof(struct A__extra_packed) == 16, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 18, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,a) == 64, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 16, "");
_Static_assert(_Alignof(E) == 16, "");
_Static_assert(sizeof(struct E_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 16, "");
_Static_assert(sizeof(struct E_extra_packed) == 16, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 18, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 8, "");
_Static_assert(sizeof(struct F_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 8, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 8, "");
_Static_assert(_Alignof(G) == 8, "");
_Static_assert(sizeof(struct G_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 8, "");
_Static_assert(sizeof(struct G_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 10, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 8, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 10, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 8, "");
_Static_assert(_Alignof(I) == 8, "");
_Static_assert(sizeof(struct I_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 10, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 16, "");
_Static_assert(_Alignof(J) == 16, "");
_Static_assert(sizeof(struct J_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 16, "");
_Static_assert(sizeof(struct J_extra_packed) == 16, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 18, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
// MAPPING|SEVEN|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(SEVEN)
_Static_assert(sizeof(A) == 128, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 130, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(A_) == 256, "");
_Static_assert(_Alignof(A_) == 128, "");
_Static_assert(sizeof(struct A__extra_alignment) == 384, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 128, "");
_Static_assert(sizeof(struct A__extra_packed) == 256, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 258, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,a) == 1024, "");
#endif
_Static_assert(sizeof(B) == 128, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 130, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 128, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 130, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 128, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 136, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 128, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 130, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 128, "");
_Static_assert(_Alignof(E) == 128, "");
_Static_assert(sizeof(struct E_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 128, "");
_Static_assert(sizeof(struct E_extra_packed) == 128, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 130, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 128, "");
_Static_assert(_Alignof(F) == 128, "");
_Static_assert(sizeof(struct F_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 128, "");
_Static_assert(sizeof(struct F_extra_packed) == 128, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 130, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 128, "");
_Static_assert(_Alignof(G) == 128, "");
_Static_assert(sizeof(struct G_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 128, "");
_Static_assert(sizeof(struct G_extra_packed) == 128, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 130, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 128, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 128, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 130, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 128, "");
_Static_assert(_Alignof(I) == 8, "");
_Static_assert(sizeof(struct I_extra_alignment) == 136, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I_extra_packed) == 128, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 130, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 128, "");
_Static_assert(_Alignof(J) == 128, "");
_Static_assert(sizeof(struct J_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 128, "");
_Static_assert(sizeof(struct J_extra_packed) == 128, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 130, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 128, "");
_Static_assert(_Alignof(K) == 128, "");
_Static_assert(sizeof(struct K_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 128, "");
_Static_assert(sizeof(struct K_extra_packed) == 128, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 130, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0046_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(1)) typedef int A;
#else
typedef int A __attribute__((aligned(1)));
#endif
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
#ifdef MSVC
__declspec(align(8)) typedef char B;
#else
typedef char B __attribute__((aligned(8)));
#endif
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
#ifdef MSVC
__declspec(align(4)) typedef int C;
#else
typedef int C __attribute__((aligned(4)));
#endif
C var9;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
#ifdef MSVC
__declspec(align(16)) typedef char unnamed_type_13;
#else
typedef char unnamed_type_13 __attribute__((aligned(16)));
#endif
unnamed_type_13 var14;
struct unnamed_type_13_extra_alignment {
char a;
unnamed_type_13 b;
};
struct unnamed_type_13_extra_alignment var15;
#pragma pack(1)
struct unnamed_type_13_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_13)];
#else
unnamed_type_13 a;
#endif
};
#pragma pack()
struct unnamed_type_13_extra_required_alignment {
char a;
struct unnamed_type_13_extra_packed b;
};
struct unnamed_type_13_extra_required_alignment var16;
struct unnamed_type_13_extra_size {
char a[sizeof(unnamed_type_13)+1];
char b;
};
struct unnamed_type_13_extra_size var17;
#ifdef MSVC
__declspec(align(4)) typedef unnamed_type_13 D;
#else
typedef unnamed_type_13 D __attribute__((aligned(4)));
#endif
D var18;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var19;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var20;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var21;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 16, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|FOUR|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0064_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(0)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A00;
A00 var1;
#pragma pack()
struct A00_extra_alignment {
char a;
A00 b;
};
struct A00_extra_alignment var2;
#pragma pack(1)
struct A00_extra_packed {
#ifdef MSVC
char a[sizeof(A00)];
#else
A00 a;
#endif
};
#pragma pack()
struct A00_extra_required_alignment {
char a;
struct A00_extra_packed b;
};
struct A00_extra_required_alignment var3;
struct A00_extra_size {
char a[sizeof(A00)+1];
char b;
};
struct A00_extra_size var4;
#pragma pack(1)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A01;
A01 var5;
#pragma pack()
struct A01_extra_alignment {
char a;
A01 b;
};
struct A01_extra_alignment var6;
#pragma pack(1)
struct A01_extra_packed {
#ifdef MSVC
char a[sizeof(A01)];
#else
A01 a;
#endif
};
#pragma pack()
struct A01_extra_required_alignment {
char a;
struct A01_extra_packed b;
};
struct A01_extra_required_alignment var7;
struct A01_extra_size {
char a[sizeof(A01)+1];
char b;
};
struct A01_extra_size var8;
#pragma pack(2)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A02;
A02 var9;
#pragma pack()
struct A02_extra_alignment {
char a;
A02 b;
};
struct A02_extra_alignment var10;
#pragma pack(1)
struct A02_extra_packed {
#ifdef MSVC
char a[sizeof(A02)];
#else
A02 a;
#endif
};
#pragma pack()
struct A02_extra_required_alignment {
char a;
struct A02_extra_packed b;
};
struct A02_extra_required_alignment var11;
struct A02_extra_size {
char a[sizeof(A02)+1];
char b;
};
struct A02_extra_size var12;
#pragma pack(3)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A03;
A03 var13;
#pragma pack()
struct A03_extra_alignment {
char a;
A03 b;
};
struct A03_extra_alignment var14;
#pragma pack(1)
struct A03_extra_packed {
#ifdef MSVC
char a[sizeof(A03)];
#else
A03 a;
#endif
};
#pragma pack()
struct A03_extra_required_alignment {
char a;
struct A03_extra_packed b;
};
struct A03_extra_required_alignment var15;
struct A03_extra_size {
char a[sizeof(A03)+1];
char b;
};
struct A03_extra_size var16;
#pragma pack(4)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A04;
A04 var17;
#pragma pack()
struct A04_extra_alignment {
char a;
A04 b;
};
struct A04_extra_alignment var18;
#pragma pack(1)
struct A04_extra_packed {
#ifdef MSVC
char a[sizeof(A04)];
#else
A04 a;
#endif
};
#pragma pack()
struct A04_extra_required_alignment {
char a;
struct A04_extra_packed b;
};
struct A04_extra_required_alignment var19;
struct A04_extra_size {
char a[sizeof(A04)+1];
char b;
};
struct A04_extra_size var20;
#pragma pack(5)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A05;
A05 var21;
#pragma pack()
struct A05_extra_alignment {
char a;
A05 b;
};
struct A05_extra_alignment var22;
#pragma pack(1)
struct A05_extra_packed {
#ifdef MSVC
char a[sizeof(A05)];
#else
A05 a;
#endif
};
#pragma pack()
struct A05_extra_required_alignment {
char a;
struct A05_extra_packed b;
};
struct A05_extra_required_alignment var23;
struct A05_extra_size {
char a[sizeof(A05)+1];
char b;
};
struct A05_extra_size var24;
#pragma pack(6)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A06;
A06 var25;
#pragma pack()
struct A06_extra_alignment {
char a;
A06 b;
};
struct A06_extra_alignment var26;
#pragma pack(1)
struct A06_extra_packed {
#ifdef MSVC
char a[sizeof(A06)];
#else
A06 a;
#endif
};
#pragma pack()
struct A06_extra_required_alignment {
char a;
struct A06_extra_packed b;
};
struct A06_extra_required_alignment var27;
struct A06_extra_size {
char a[sizeof(A06)+1];
char b;
};
struct A06_extra_size var28;
#pragma pack(7)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A07;
A07 var29;
#pragma pack()
struct A07_extra_alignment {
char a;
A07 b;
};
struct A07_extra_alignment var30;
#pragma pack(1)
struct A07_extra_packed {
#ifdef MSVC
char a[sizeof(A07)];
#else
A07 a;
#endif
};
#pragma pack()
struct A07_extra_required_alignment {
char a;
struct A07_extra_packed b;
};
struct A07_extra_required_alignment var31;
struct A07_extra_size {
char a[sizeof(A07)+1];
char b;
};
struct A07_extra_size var32;
#pragma pack(8)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A08;
A08 var33;
#pragma pack()
struct A08_extra_alignment {
char a;
A08 b;
};
struct A08_extra_alignment var34;
#pragma pack(1)
struct A08_extra_packed {
#ifdef MSVC
char a[sizeof(A08)];
#else
A08 a;
#endif
};
#pragma pack()
struct A08_extra_required_alignment {
char a;
struct A08_extra_packed b;
};
struct A08_extra_required_alignment var35;
struct A08_extra_size {
char a[sizeof(A08)+1];
char b;
};
struct A08_extra_size var36;
#pragma pack(9)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A09;
A09 var37;
#pragma pack()
struct A09_extra_alignment {
char a;
A09 b;
};
struct A09_extra_alignment var38;
#pragma pack(1)
struct A09_extra_packed {
#ifdef MSVC
char a[sizeof(A09)];
#else
A09 a;
#endif
};
#pragma pack()
struct A09_extra_required_alignment {
char a;
struct A09_extra_packed b;
};
struct A09_extra_required_alignment var39;
struct A09_extra_size {
char a[sizeof(A09)+1];
char b;
};
struct A09_extra_size var40;
#pragma pack(10)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A10;
A10 var41;
#pragma pack()
struct A10_extra_alignment {
char a;
A10 b;
};
struct A10_extra_alignment var42;
#pragma pack(1)
struct A10_extra_packed {
#ifdef MSVC
char a[sizeof(A10)];
#else
A10 a;
#endif
};
#pragma pack()
struct A10_extra_required_alignment {
char a;
struct A10_extra_packed b;
};
struct A10_extra_required_alignment var43;
struct A10_extra_size {
char a[sizeof(A10)+1];
char b;
};
struct A10_extra_size var44;
#pragma pack(11)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A11;
A11 var45;
#pragma pack()
struct A11_extra_alignment {
char a;
A11 b;
};
struct A11_extra_alignment var46;
#pragma pack(1)
struct A11_extra_packed {
#ifdef MSVC
char a[sizeof(A11)];
#else
A11 a;
#endif
};
#pragma pack()
struct A11_extra_required_alignment {
char a;
struct A11_extra_packed b;
};
struct A11_extra_required_alignment var47;
struct A11_extra_size {
char a[sizeof(A11)+1];
char b;
};
struct A11_extra_size var48;
#pragma pack(12)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A12;
A12 var49;
#pragma pack()
struct A12_extra_alignment {
char a;
A12 b;
};
struct A12_extra_alignment var50;
#pragma pack(1)
struct A12_extra_packed {
#ifdef MSVC
char a[sizeof(A12)];
#else
A12 a;
#endif
};
#pragma pack()
struct A12_extra_required_alignment {
char a;
struct A12_extra_packed b;
};
struct A12_extra_required_alignment var51;
struct A12_extra_size {
char a[sizeof(A12)+1];
char b;
};
struct A12_extra_size var52;
#pragma pack(13)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A13;
A13 var53;
#pragma pack()
struct A13_extra_alignment {
char a;
A13 b;
};
struct A13_extra_alignment var54;
#pragma pack(1)
struct A13_extra_packed {
#ifdef MSVC
char a[sizeof(A13)];
#else
A13 a;
#endif
};
#pragma pack()
struct A13_extra_required_alignment {
char a;
struct A13_extra_packed b;
};
struct A13_extra_required_alignment var55;
struct A13_extra_size {
char a[sizeof(A13)+1];
char b;
};
struct A13_extra_size var56;
#pragma pack(14)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A14;
A14 var57;
#pragma pack()
struct A14_extra_alignment {
char a;
A14 b;
};
struct A14_extra_alignment var58;
#pragma pack(1)
struct A14_extra_packed {
#ifdef MSVC
char a[sizeof(A14)];
#else
A14 a;
#endif
};
#pragma pack()
struct A14_extra_required_alignment {
char a;
struct A14_extra_packed b;
};
struct A14_extra_required_alignment var59;
struct A14_extra_size {
char a[sizeof(A14)+1];
char b;
};
struct A14_extra_size var60;
#pragma pack(15)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A15;
A15 var61;
#pragma pack()
struct A15_extra_alignment {
char a;
A15 b;
};
struct A15_extra_alignment var62;
#pragma pack(1)
struct A15_extra_packed {
#ifdef MSVC
char a[sizeof(A15)];
#else
A15 a;
#endif
};
#pragma pack()
struct A15_extra_required_alignment {
char a;
struct A15_extra_packed b;
};
struct A15_extra_required_alignment var63;
struct A15_extra_size {
char a[sizeof(A15)+1];
char b;
};
struct A15_extra_size var64;
#pragma pack(16)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A16;
A16 var65;
#pragma pack()
struct A16_extra_alignment {
char a;
A16 b;
};
struct A16_extra_alignment var66;
#pragma pack(1)
struct A16_extra_packed {
#ifdef MSVC
char a[sizeof(A16)];
#else
A16 a;
#endif
};
#pragma pack()
struct A16_extra_required_alignment {
char a;
struct A16_extra_packed b;
};
struct A16_extra_required_alignment var67;
struct A16_extra_size {
char a[sizeof(A16)+1];
char b;
};
struct A16_extra_size var68;
#pragma pack(17)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A17;
A17 var69;
#pragma pack()
struct A17_extra_alignment {
char a;
A17 b;
};
struct A17_extra_alignment var70;
#pragma pack(1)
struct A17_extra_packed {
#ifdef MSVC
char a[sizeof(A17)];
#else
A17 a;
#endif
};
#pragma pack()
struct A17_extra_required_alignment {
char a;
struct A17_extra_packed b;
};
struct A17_extra_required_alignment var71;
struct A17_extra_size {
char a[sizeof(A17)+1];
char b;
};
struct A17_extra_size var72;
#pragma pack(18)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A18;
A18 var73;
#pragma pack()
struct A18_extra_alignment {
char a;
A18 b;
};
struct A18_extra_alignment var74;
#pragma pack(1)
struct A18_extra_packed {
#ifdef MSVC
char a[sizeof(A18)];
#else
A18 a;
#endif
};
#pragma pack()
struct A18_extra_required_alignment {
char a;
struct A18_extra_packed b;
};
struct A18_extra_required_alignment var75;
struct A18_extra_size {
char a[sizeof(A18)+1];
char b;
};
struct A18_extra_size var76;
#pragma pack(19)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A19;
A19 var77;
#pragma pack()
struct A19_extra_alignment {
char a;
A19 b;
};
struct A19_extra_alignment var78;
#pragma pack(1)
struct A19_extra_packed {
#ifdef MSVC
char a[sizeof(A19)];
#else
A19 a;
#endif
};
#pragma pack()
struct A19_extra_required_alignment {
char a;
struct A19_extra_packed b;
};
struct A19_extra_required_alignment var79;
struct A19_extra_size {
char a[sizeof(A19)+1];
char b;
};
struct A19_extra_size var80;
#pragma pack(20)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A20;
A20 var81;
#pragma pack()
struct A20_extra_alignment {
char a;
A20 b;
};
struct A20_extra_alignment var82;
#pragma pack(1)
struct A20_extra_packed {
#ifdef MSVC
char a[sizeof(A20)];
#else
A20 a;
#endif
};
#pragma pack()
struct A20_extra_required_alignment {
char a;
struct A20_extra_packed b;
};
struct A20_extra_required_alignment var83;
struct A20_extra_size {
char a[sizeof(A20)+1];
char b;
};
struct A20_extra_size var84;
#pragma pack(21)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A21;
A21 var85;
#pragma pack()
struct A21_extra_alignment {
char a;
A21 b;
};
struct A21_extra_alignment var86;
#pragma pack(1)
struct A21_extra_packed {
#ifdef MSVC
char a[sizeof(A21)];
#else
A21 a;
#endif
};
#pragma pack()
struct A21_extra_required_alignment {
char a;
struct A21_extra_packed b;
};
struct A21_extra_required_alignment var87;
struct A21_extra_size {
char a[sizeof(A21)+1];
char b;
};
struct A21_extra_size var88;
#pragma pack(22)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A22;
A22 var89;
#pragma pack()
struct A22_extra_alignment {
char a;
A22 b;
};
struct A22_extra_alignment var90;
#pragma pack(1)
struct A22_extra_packed {
#ifdef MSVC
char a[sizeof(A22)];
#else
A22 a;
#endif
};
#pragma pack()
struct A22_extra_required_alignment {
char a;
struct A22_extra_packed b;
};
struct A22_extra_required_alignment var91;
struct A22_extra_size {
char a[sizeof(A22)+1];
char b;
};
struct A22_extra_size var92;
#pragma pack(23)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A23;
A23 var93;
#pragma pack()
struct A23_extra_alignment {
char a;
A23 b;
};
struct A23_extra_alignment var94;
#pragma pack(1)
struct A23_extra_packed {
#ifdef MSVC
char a[sizeof(A23)];
#else
A23 a;
#endif
};
#pragma pack()
struct A23_extra_required_alignment {
char a;
struct A23_extra_packed b;
};
struct A23_extra_required_alignment var95;
struct A23_extra_size {
char a[sizeof(A23)+1];
char b;
};
struct A23_extra_size var96;
#pragma pack(24)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A24;
A24 var97;
#pragma pack()
struct A24_extra_alignment {
char a;
A24 b;
};
struct A24_extra_alignment var98;
#pragma pack(1)
struct A24_extra_packed {
#ifdef MSVC
char a[sizeof(A24)];
#else
A24 a;
#endif
};
#pragma pack()
struct A24_extra_required_alignment {
char a;
struct A24_extra_packed b;
};
struct A24_extra_required_alignment var99;
struct A24_extra_size {
char a[sizeof(A24)+1];
char b;
};
struct A24_extra_size var100;
#pragma pack(25)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A25;
A25 var101;
#pragma pack()
struct A25_extra_alignment {
char a;
A25 b;
};
struct A25_extra_alignment var102;
#pragma pack(1)
struct A25_extra_packed {
#ifdef MSVC
char a[sizeof(A25)];
#else
A25 a;
#endif
};
#pragma pack()
struct A25_extra_required_alignment {
char a;
struct A25_extra_packed b;
};
struct A25_extra_required_alignment var103;
struct A25_extra_size {
char a[sizeof(A25)+1];
char b;
};
struct A25_extra_size var104;
#pragma pack(26)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A26;
A26 var105;
#pragma pack()
struct A26_extra_alignment {
char a;
A26 b;
};
struct A26_extra_alignment var106;
#pragma pack(1)
struct A26_extra_packed {
#ifdef MSVC
char a[sizeof(A26)];
#else
A26 a;
#endif
};
#pragma pack()
struct A26_extra_required_alignment {
char a;
struct A26_extra_packed b;
};
struct A26_extra_required_alignment var107;
struct A26_extra_size {
char a[sizeof(A26)+1];
char b;
};
struct A26_extra_size var108;
#pragma pack(27)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A27;
A27 var109;
#pragma pack()
struct A27_extra_alignment {
char a;
A27 b;
};
struct A27_extra_alignment var110;
#pragma pack(1)
struct A27_extra_packed {
#ifdef MSVC
char a[sizeof(A27)];
#else
A27 a;
#endif
};
#pragma pack()
struct A27_extra_required_alignment {
char a;
struct A27_extra_packed b;
};
struct A27_extra_required_alignment var111;
struct A27_extra_size {
char a[sizeof(A27)+1];
char b;
};
struct A27_extra_size var112;
#pragma pack(28)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A28;
A28 var113;
#pragma pack()
struct A28_extra_alignment {
char a;
A28 b;
};
struct A28_extra_alignment var114;
#pragma pack(1)
struct A28_extra_packed {
#ifdef MSVC
char a[sizeof(A28)];
#else
A28 a;
#endif
};
#pragma pack()
struct A28_extra_required_alignment {
char a;
struct A28_extra_packed b;
};
struct A28_extra_required_alignment var115;
struct A28_extra_size {
char a[sizeof(A28)+1];
char b;
};
struct A28_extra_size var116;
#pragma pack(29)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A29;
A29 var117;
#pragma pack()
struct A29_extra_alignment {
char a;
A29 b;
};
struct A29_extra_alignment var118;
#pragma pack(1)
struct A29_extra_packed {
#ifdef MSVC
char a[sizeof(A29)];
#else
A29 a;
#endif
};
#pragma pack()
struct A29_extra_required_alignment {
char a;
struct A29_extra_packed b;
};
struct A29_extra_required_alignment var119;
struct A29_extra_size {
char a[sizeof(A29)+1];
char b;
};
struct A29_extra_size var120;
#pragma pack(30)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A30;
A30 var121;
#pragma pack()
struct A30_extra_alignment {
char a;
A30 b;
};
struct A30_extra_alignment var122;
#pragma pack(1)
struct A30_extra_packed {
#ifdef MSVC
char a[sizeof(A30)];
#else
A30 a;
#endif
};
#pragma pack()
struct A30_extra_required_alignment {
char a;
struct A30_extra_packed b;
};
struct A30_extra_required_alignment var123;
struct A30_extra_size {
char a[sizeof(A30)+1];
char b;
};
struct A30_extra_size var124;
#pragma pack(31)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A31;
A31 var125;
#pragma pack()
struct A31_extra_alignment {
char a;
A31 b;
};
struct A31_extra_alignment var126;
#pragma pack(1)
struct A31_extra_packed {
#ifdef MSVC
char a[sizeof(A31)];
#else
A31 a;
#endif
};
#pragma pack()
struct A31_extra_required_alignment {
char a;
struct A31_extra_packed b;
};
struct A31_extra_required_alignment var127;
struct A31_extra_size {
char a[sizeof(A31)+1];
char b;
};
struct A31_extra_size var128;
#pragma pack(32)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A32;
A32 var129;
#pragma pack()
struct A32_extra_alignment {
char a;
A32 b;
};
struct A32_extra_alignment var130;
#pragma pack(1)
struct A32_extra_packed {
#ifdef MSVC
char a[sizeof(A32)];
#else
A32 a;
#endif
};
#pragma pack()
struct A32_extra_required_alignment {
char a;
struct A32_extra_packed b;
};
struct A32_extra_required_alignment var131;
struct A32_extra_size {
char a[sizeof(A32)+1];
char b;
};
struct A32_extra_size var132;
#pragma pack(33)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A33;
A33 var133;
#pragma pack()
struct A33_extra_alignment {
char a;
A33 b;
};
struct A33_extra_alignment var134;
#pragma pack(1)
struct A33_extra_packed {
#ifdef MSVC
char a[sizeof(A33)];
#else
A33 a;
#endif
};
#pragma pack()
struct A33_extra_required_alignment {
char a;
struct A33_extra_packed b;
};
struct A33_extra_required_alignment var135;
struct A33_extra_size {
char a[sizeof(A33)+1];
char b;
};
struct A33_extra_size var136;
#pragma pack(34)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A34;
A34 var137;
#pragma pack()
struct A34_extra_alignment {
char a;
A34 b;
};
struct A34_extra_alignment var138;
#pragma pack(1)
struct A34_extra_packed {
#ifdef MSVC
char a[sizeof(A34)];
#else
A34 a;
#endif
};
#pragma pack()
struct A34_extra_required_alignment {
char a;
struct A34_extra_packed b;
};
struct A34_extra_required_alignment var139;
struct A34_extra_size {
char a[sizeof(A34)+1];
char b;
};
struct A34_extra_size var140;
#pragma pack(35)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A35;
A35 var141;
#pragma pack()
struct A35_extra_alignment {
char a;
A35 b;
};
struct A35_extra_alignment var142;
#pragma pack(1)
struct A35_extra_packed {
#ifdef MSVC
char a[sizeof(A35)];
#else
A35 a;
#endif
};
#pragma pack()
struct A35_extra_required_alignment {
char a;
struct A35_extra_packed b;
};
struct A35_extra_required_alignment var143;
struct A35_extra_size {
char a[sizeof(A35)+1];
char b;
};
struct A35_extra_size var144;
#pragma pack(36)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A36;
A36 var145;
#pragma pack()
struct A36_extra_alignment {
char a;
A36 b;
};
struct A36_extra_alignment var146;
#pragma pack(1)
struct A36_extra_packed {
#ifdef MSVC
char a[sizeof(A36)];
#else
A36 a;
#endif
};
#pragma pack()
struct A36_extra_required_alignment {
char a;
struct A36_extra_packed b;
};
struct A36_extra_required_alignment var147;
struct A36_extra_size {
char a[sizeof(A36)+1];
char b;
};
struct A36_extra_size var148;
#pragma pack(37)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A37;
A37 var149;
#pragma pack()
struct A37_extra_alignment {
char a;
A37 b;
};
struct A37_extra_alignment var150;
#pragma pack(1)
struct A37_extra_packed {
#ifdef MSVC
char a[sizeof(A37)];
#else
A37 a;
#endif
};
#pragma pack()
struct A37_extra_required_alignment {
char a;
struct A37_extra_packed b;
};
struct A37_extra_required_alignment var151;
struct A37_extra_size {
char a[sizeof(A37)+1];
char b;
};
struct A37_extra_size var152;
#pragma pack(38)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A38;
A38 var153;
#pragma pack()
struct A38_extra_alignment {
char a;
A38 b;
};
struct A38_extra_alignment var154;
#pragma pack(1)
struct A38_extra_packed {
#ifdef MSVC
char a[sizeof(A38)];
#else
A38 a;
#endif
};
#pragma pack()
struct A38_extra_required_alignment {
char a;
struct A38_extra_packed b;
};
struct A38_extra_required_alignment var155;
struct A38_extra_size {
char a[sizeof(A38)+1];
char b;
};
struct A38_extra_size var156;
#pragma pack(39)
typedef struct {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} A39;
A39 var157;
#pragma pack()
struct A39_extra_alignment {
char a;
A39 b;
};
struct A39_extra_alignment var158;
#pragma pack(1)
struct A39_extra_packed {
#ifdef MSVC
char a[sizeof(A39)];
#else
A39 a;
#endif
};
#pragma pack()
struct A39_extra_required_alignment {
char a;
struct A39_extra_packed b;
};
struct A39_extra_required_alignment var159;
struct A39_extra_size {
char a[sizeof(A39)+1];
char b;
};
struct A39_extra_size var160;
#pragma pack(0)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B00;
B00 var161;
#pragma pack()
struct B00_extra_alignment {
char a;
B00 b;
};
struct B00_extra_alignment var162;
#pragma pack(1)
struct B00_extra_packed {
#ifdef MSVC
char a[sizeof(B00)];
#else
B00 a;
#endif
};
#pragma pack()
struct B00_extra_required_alignment {
char a;
struct B00_extra_packed b;
};
struct B00_extra_required_alignment var163;
struct B00_extra_size {
char a[sizeof(B00)+1];
char b;
};
struct B00_extra_size var164;
#pragma pack(1)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B01;
B01 var165;
#pragma pack()
struct B01_extra_alignment {
char a;
B01 b;
};
struct B01_extra_alignment var166;
#pragma pack(1)
struct B01_extra_packed {
#ifdef MSVC
char a[sizeof(B01)];
#else
B01 a;
#endif
};
#pragma pack()
struct B01_extra_required_alignment {
char a;
struct B01_extra_packed b;
};
struct B01_extra_required_alignment var167;
struct B01_extra_size {
char a[sizeof(B01)+1];
char b;
};
struct B01_extra_size var168;
#pragma pack(2)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B02;
B02 var169;
#pragma pack()
struct B02_extra_alignment {
char a;
B02 b;
};
struct B02_extra_alignment var170;
#pragma pack(1)
struct B02_extra_packed {
#ifdef MSVC
char a[sizeof(B02)];
#else
B02 a;
#endif
};
#pragma pack()
struct B02_extra_required_alignment {
char a;
struct B02_extra_packed b;
};
struct B02_extra_required_alignment var171;
struct B02_extra_size {
char a[sizeof(B02)+1];
char b;
};
struct B02_extra_size var172;
#pragma pack(3)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B03;
B03 var173;
#pragma pack()
struct B03_extra_alignment {
char a;
B03 b;
};
struct B03_extra_alignment var174;
#pragma pack(1)
struct B03_extra_packed {
#ifdef MSVC
char a[sizeof(B03)];
#else
B03 a;
#endif
};
#pragma pack()
struct B03_extra_required_alignment {
char a;
struct B03_extra_packed b;
};
struct B03_extra_required_alignment var175;
struct B03_extra_size {
char a[sizeof(B03)+1];
char b;
};
struct B03_extra_size var176;
#pragma pack(4)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B04;
B04 var177;
#pragma pack()
struct B04_extra_alignment {
char a;
B04 b;
};
struct B04_extra_alignment var178;
#pragma pack(1)
struct B04_extra_packed {
#ifdef MSVC
char a[sizeof(B04)];
#else
B04 a;
#endif
};
#pragma pack()
struct B04_extra_required_alignment {
char a;
struct B04_extra_packed b;
};
struct B04_extra_required_alignment var179;
struct B04_extra_size {
char a[sizeof(B04)+1];
char b;
};
struct B04_extra_size var180;
#pragma pack(5)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B05;
B05 var181;
#pragma pack()
struct B05_extra_alignment {
char a;
B05 b;
};
struct B05_extra_alignment var182;
#pragma pack(1)
struct B05_extra_packed {
#ifdef MSVC
char a[sizeof(B05)];
#else
B05 a;
#endif
};
#pragma pack()
struct B05_extra_required_alignment {
char a;
struct B05_extra_packed b;
};
struct B05_extra_required_alignment var183;
struct B05_extra_size {
char a[sizeof(B05)+1];
char b;
};
struct B05_extra_size var184;
#pragma pack(6)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B06;
B06 var185;
#pragma pack()
struct B06_extra_alignment {
char a;
B06 b;
};
struct B06_extra_alignment var186;
#pragma pack(1)
struct B06_extra_packed {
#ifdef MSVC
char a[sizeof(B06)];
#else
B06 a;
#endif
};
#pragma pack()
struct B06_extra_required_alignment {
char a;
struct B06_extra_packed b;
};
struct B06_extra_required_alignment var187;
struct B06_extra_size {
char a[sizeof(B06)+1];
char b;
};
struct B06_extra_size var188;
#pragma pack(7)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B07;
B07 var189;
#pragma pack()
struct B07_extra_alignment {
char a;
B07 b;
};
struct B07_extra_alignment var190;
#pragma pack(1)
struct B07_extra_packed {
#ifdef MSVC
char a[sizeof(B07)];
#else
B07 a;
#endif
};
#pragma pack()
struct B07_extra_required_alignment {
char a;
struct B07_extra_packed b;
};
struct B07_extra_required_alignment var191;
struct B07_extra_size {
char a[sizeof(B07)+1];
char b;
};
struct B07_extra_size var192;
#pragma pack(8)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B08;
B08 var193;
#pragma pack()
struct B08_extra_alignment {
char a;
B08 b;
};
struct B08_extra_alignment var194;
#pragma pack(1)
struct B08_extra_packed {
#ifdef MSVC
char a[sizeof(B08)];
#else
B08 a;
#endif
};
#pragma pack()
struct B08_extra_required_alignment {
char a;
struct B08_extra_packed b;
};
struct B08_extra_required_alignment var195;
struct B08_extra_size {
char a[sizeof(B08)+1];
char b;
};
struct B08_extra_size var196;
#pragma pack(9)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B09;
B09 var197;
#pragma pack()
struct B09_extra_alignment {
char a;
B09 b;
};
struct B09_extra_alignment var198;
#pragma pack(1)
struct B09_extra_packed {
#ifdef MSVC
char a[sizeof(B09)];
#else
B09 a;
#endif
};
#pragma pack()
struct B09_extra_required_alignment {
char a;
struct B09_extra_packed b;
};
struct B09_extra_required_alignment var199;
struct B09_extra_size {
char a[sizeof(B09)+1];
char b;
};
struct B09_extra_size var200;
#pragma pack(10)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B10;
B10 var201;
#pragma pack()
struct B10_extra_alignment {
char a;
B10 b;
};
struct B10_extra_alignment var202;
#pragma pack(1)
struct B10_extra_packed {
#ifdef MSVC
char a[sizeof(B10)];
#else
B10 a;
#endif
};
#pragma pack()
struct B10_extra_required_alignment {
char a;
struct B10_extra_packed b;
};
struct B10_extra_required_alignment var203;
struct B10_extra_size {
char a[sizeof(B10)+1];
char b;
};
struct B10_extra_size var204;
#pragma pack(11)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B11;
B11 var205;
#pragma pack()
struct B11_extra_alignment {
char a;
B11 b;
};
struct B11_extra_alignment var206;
#pragma pack(1)
struct B11_extra_packed {
#ifdef MSVC
char a[sizeof(B11)];
#else
B11 a;
#endif
};
#pragma pack()
struct B11_extra_required_alignment {
char a;
struct B11_extra_packed b;
};
struct B11_extra_required_alignment var207;
struct B11_extra_size {
char a[sizeof(B11)+1];
char b;
};
struct B11_extra_size var208;
#pragma pack(12)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B12;
B12 var209;
#pragma pack()
struct B12_extra_alignment {
char a;
B12 b;
};
struct B12_extra_alignment var210;
#pragma pack(1)
struct B12_extra_packed {
#ifdef MSVC
char a[sizeof(B12)];
#else
B12 a;
#endif
};
#pragma pack()
struct B12_extra_required_alignment {
char a;
struct B12_extra_packed b;
};
struct B12_extra_required_alignment var211;
struct B12_extra_size {
char a[sizeof(B12)+1];
char b;
};
struct B12_extra_size var212;
#pragma pack(13)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B13;
B13 var213;
#pragma pack()
struct B13_extra_alignment {
char a;
B13 b;
};
struct B13_extra_alignment var214;
#pragma pack(1)
struct B13_extra_packed {
#ifdef MSVC
char a[sizeof(B13)];
#else
B13 a;
#endif
};
#pragma pack()
struct B13_extra_required_alignment {
char a;
struct B13_extra_packed b;
};
struct B13_extra_required_alignment var215;
struct B13_extra_size {
char a[sizeof(B13)+1];
char b;
};
struct B13_extra_size var216;
#pragma pack(14)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B14;
B14 var217;
#pragma pack()
struct B14_extra_alignment {
char a;
B14 b;
};
struct B14_extra_alignment var218;
#pragma pack(1)
struct B14_extra_packed {
#ifdef MSVC
char a[sizeof(B14)];
#else
B14 a;
#endif
};
#pragma pack()
struct B14_extra_required_alignment {
char a;
struct B14_extra_packed b;
};
struct B14_extra_required_alignment var219;
struct B14_extra_size {
char a[sizeof(B14)+1];
char b;
};
struct B14_extra_size var220;
#pragma pack(15)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B15;
B15 var221;
#pragma pack()
struct B15_extra_alignment {
char a;
B15 b;
};
struct B15_extra_alignment var222;
#pragma pack(1)
struct B15_extra_packed {
#ifdef MSVC
char a[sizeof(B15)];
#else
B15 a;
#endif
};
#pragma pack()
struct B15_extra_required_alignment {
char a;
struct B15_extra_packed b;
};
struct B15_extra_required_alignment var223;
struct B15_extra_size {
char a[sizeof(B15)+1];
char b;
};
struct B15_extra_size var224;
#pragma pack(16)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B16;
B16 var225;
#pragma pack()
struct B16_extra_alignment {
char a;
B16 b;
};
struct B16_extra_alignment var226;
#pragma pack(1)
struct B16_extra_packed {
#ifdef MSVC
char a[sizeof(B16)];
#else
B16 a;
#endif
};
#pragma pack()
struct B16_extra_required_alignment {
char a;
struct B16_extra_packed b;
};
struct B16_extra_required_alignment var227;
struct B16_extra_size {
char a[sizeof(B16)+1];
char b;
};
struct B16_extra_size var228;
#pragma pack(17)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B17;
B17 var229;
#pragma pack()
struct B17_extra_alignment {
char a;
B17 b;
};
struct B17_extra_alignment var230;
#pragma pack(1)
struct B17_extra_packed {
#ifdef MSVC
char a[sizeof(B17)];
#else
B17 a;
#endif
};
#pragma pack()
struct B17_extra_required_alignment {
char a;
struct B17_extra_packed b;
};
struct B17_extra_required_alignment var231;
struct B17_extra_size {
char a[sizeof(B17)+1];
char b;
};
struct B17_extra_size var232;
#pragma pack(18)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B18;
B18 var233;
#pragma pack()
struct B18_extra_alignment {
char a;
B18 b;
};
struct B18_extra_alignment var234;
#pragma pack(1)
struct B18_extra_packed {
#ifdef MSVC
char a[sizeof(B18)];
#else
B18 a;
#endif
};
#pragma pack()
struct B18_extra_required_alignment {
char a;
struct B18_extra_packed b;
};
struct B18_extra_required_alignment var235;
struct B18_extra_size {
char a[sizeof(B18)+1];
char b;
};
struct B18_extra_size var236;
#pragma pack(19)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B19;
B19 var237;
#pragma pack()
struct B19_extra_alignment {
char a;
B19 b;
};
struct B19_extra_alignment var238;
#pragma pack(1)
struct B19_extra_packed {
#ifdef MSVC
char a[sizeof(B19)];
#else
B19 a;
#endif
};
#pragma pack()
struct B19_extra_required_alignment {
char a;
struct B19_extra_packed b;
};
struct B19_extra_required_alignment var239;
struct B19_extra_size {
char a[sizeof(B19)+1];
char b;
};
struct B19_extra_size var240;
#pragma pack(20)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B20;
B20 var241;
#pragma pack()
struct B20_extra_alignment {
char a;
B20 b;
};
struct B20_extra_alignment var242;
#pragma pack(1)
struct B20_extra_packed {
#ifdef MSVC
char a[sizeof(B20)];
#else
B20 a;
#endif
};
#pragma pack()
struct B20_extra_required_alignment {
char a;
struct B20_extra_packed b;
};
struct B20_extra_required_alignment var243;
struct B20_extra_size {
char a[sizeof(B20)+1];
char b;
};
struct B20_extra_size var244;
#pragma pack(21)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B21;
B21 var245;
#pragma pack()
struct B21_extra_alignment {
char a;
B21 b;
};
struct B21_extra_alignment var246;
#pragma pack(1)
struct B21_extra_packed {
#ifdef MSVC
char a[sizeof(B21)];
#else
B21 a;
#endif
};
#pragma pack()
struct B21_extra_required_alignment {
char a;
struct B21_extra_packed b;
};
struct B21_extra_required_alignment var247;
struct B21_extra_size {
char a[sizeof(B21)+1];
char b;
};
struct B21_extra_size var248;
#pragma pack(22)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B22;
B22 var249;
#pragma pack()
struct B22_extra_alignment {
char a;
B22 b;
};
struct B22_extra_alignment var250;
#pragma pack(1)
struct B22_extra_packed {
#ifdef MSVC
char a[sizeof(B22)];
#else
B22 a;
#endif
};
#pragma pack()
struct B22_extra_required_alignment {
char a;
struct B22_extra_packed b;
};
struct B22_extra_required_alignment var251;
struct B22_extra_size {
char a[sizeof(B22)+1];
char b;
};
struct B22_extra_size var252;
#pragma pack(23)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B23;
B23 var253;
#pragma pack()
struct B23_extra_alignment {
char a;
B23 b;
};
struct B23_extra_alignment var254;
#pragma pack(1)
struct B23_extra_packed {
#ifdef MSVC
char a[sizeof(B23)];
#else
B23 a;
#endif
};
#pragma pack()
struct B23_extra_required_alignment {
char a;
struct B23_extra_packed b;
};
struct B23_extra_required_alignment var255;
struct B23_extra_size {
char a[sizeof(B23)+1];
char b;
};
struct B23_extra_size var256;
#pragma pack(24)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B24;
B24 var257;
#pragma pack()
struct B24_extra_alignment {
char a;
B24 b;
};
struct B24_extra_alignment var258;
#pragma pack(1)
struct B24_extra_packed {
#ifdef MSVC
char a[sizeof(B24)];
#else
B24 a;
#endif
};
#pragma pack()
struct B24_extra_required_alignment {
char a;
struct B24_extra_packed b;
};
struct B24_extra_required_alignment var259;
struct B24_extra_size {
char a[sizeof(B24)+1];
char b;
};
struct B24_extra_size var260;
#pragma pack(25)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B25;
B25 var261;
#pragma pack()
struct B25_extra_alignment {
char a;
B25 b;
};
struct B25_extra_alignment var262;
#pragma pack(1)
struct B25_extra_packed {
#ifdef MSVC
char a[sizeof(B25)];
#else
B25 a;
#endif
};
#pragma pack()
struct B25_extra_required_alignment {
char a;
struct B25_extra_packed b;
};
struct B25_extra_required_alignment var263;
struct B25_extra_size {
char a[sizeof(B25)+1];
char b;
};
struct B25_extra_size var264;
#pragma pack(26)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B26;
B26 var265;
#pragma pack()
struct B26_extra_alignment {
char a;
B26 b;
};
struct B26_extra_alignment var266;
#pragma pack(1)
struct B26_extra_packed {
#ifdef MSVC
char a[sizeof(B26)];
#else
B26 a;
#endif
};
#pragma pack()
struct B26_extra_required_alignment {
char a;
struct B26_extra_packed b;
};
struct B26_extra_required_alignment var267;
struct B26_extra_size {
char a[sizeof(B26)+1];
char b;
};
struct B26_extra_size var268;
#pragma pack(27)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B27;
B27 var269;
#pragma pack()
struct B27_extra_alignment {
char a;
B27 b;
};
struct B27_extra_alignment var270;
#pragma pack(1)
struct B27_extra_packed {
#ifdef MSVC
char a[sizeof(B27)];
#else
B27 a;
#endif
};
#pragma pack()
struct B27_extra_required_alignment {
char a;
struct B27_extra_packed b;
};
struct B27_extra_required_alignment var271;
struct B27_extra_size {
char a[sizeof(B27)+1];
char b;
};
struct B27_extra_size var272;
#pragma pack(28)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B28;
B28 var273;
#pragma pack()
struct B28_extra_alignment {
char a;
B28 b;
};
struct B28_extra_alignment var274;
#pragma pack(1)
struct B28_extra_packed {
#ifdef MSVC
char a[sizeof(B28)];
#else
B28 a;
#endif
};
#pragma pack()
struct B28_extra_required_alignment {
char a;
struct B28_extra_packed b;
};
struct B28_extra_required_alignment var275;
struct B28_extra_size {
char a[sizeof(B28)+1];
char b;
};
struct B28_extra_size var276;
#pragma pack(29)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B29;
B29 var277;
#pragma pack()
struct B29_extra_alignment {
char a;
B29 b;
};
struct B29_extra_alignment var278;
#pragma pack(1)
struct B29_extra_packed {
#ifdef MSVC
char a[sizeof(B29)];
#else
B29 a;
#endif
};
#pragma pack()
struct B29_extra_required_alignment {
char a;
struct B29_extra_packed b;
};
struct B29_extra_required_alignment var279;
struct B29_extra_size {
char a[sizeof(B29)+1];
char b;
};
struct B29_extra_size var280;
#pragma pack(30)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B30;
B30 var281;
#pragma pack()
struct B30_extra_alignment {
char a;
B30 b;
};
struct B30_extra_alignment var282;
#pragma pack(1)
struct B30_extra_packed {
#ifdef MSVC
char a[sizeof(B30)];
#else
B30 a;
#endif
};
#pragma pack()
struct B30_extra_required_alignment {
char a;
struct B30_extra_packed b;
};
struct B30_extra_required_alignment var283;
struct B30_extra_size {
char a[sizeof(B30)+1];
char b;
};
struct B30_extra_size var284;
#pragma pack(31)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B31;
B31 var285;
#pragma pack()
struct B31_extra_alignment {
char a;
B31 b;
};
struct B31_extra_alignment var286;
#pragma pack(1)
struct B31_extra_packed {
#ifdef MSVC
char a[sizeof(B31)];
#else
B31 a;
#endif
};
#pragma pack()
struct B31_extra_required_alignment {
char a;
struct B31_extra_packed b;
};
struct B31_extra_required_alignment var287;
struct B31_extra_size {
char a[sizeof(B31)+1];
char b;
};
struct B31_extra_size var288;
#pragma pack(32)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B32;
B32 var289;
#pragma pack()
struct B32_extra_alignment {
char a;
B32 b;
};
struct B32_extra_alignment var290;
#pragma pack(1)
struct B32_extra_packed {
#ifdef MSVC
char a[sizeof(B32)];
#else
B32 a;
#endif
};
#pragma pack()
struct B32_extra_required_alignment {
char a;
struct B32_extra_packed b;
};
struct B32_extra_required_alignment var291;
struct B32_extra_size {
char a[sizeof(B32)+1];
char b;
};
struct B32_extra_size var292;
#pragma pack(33)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B33;
B33 var293;
#pragma pack()
struct B33_extra_alignment {
char a;
B33 b;
};
struct B33_extra_alignment var294;
#pragma pack(1)
struct B33_extra_packed {
#ifdef MSVC
char a[sizeof(B33)];
#else
B33 a;
#endif
};
#pragma pack()
struct B33_extra_required_alignment {
char a;
struct B33_extra_packed b;
};
struct B33_extra_required_alignment var295;
struct B33_extra_size {
char a[sizeof(B33)+1];
char b;
};
struct B33_extra_size var296;
#pragma pack(34)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B34;
B34 var297;
#pragma pack()
struct B34_extra_alignment {
char a;
B34 b;
};
struct B34_extra_alignment var298;
#pragma pack(1)
struct B34_extra_packed {
#ifdef MSVC
char a[sizeof(B34)];
#else
B34 a;
#endif
};
#pragma pack()
struct B34_extra_required_alignment {
char a;
struct B34_extra_packed b;
};
struct B34_extra_required_alignment var299;
struct B34_extra_size {
char a[sizeof(B34)+1];
char b;
};
struct B34_extra_size var300;
#pragma pack(35)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B35;
B35 var301;
#pragma pack()
struct B35_extra_alignment {
char a;
B35 b;
};
struct B35_extra_alignment var302;
#pragma pack(1)
struct B35_extra_packed {
#ifdef MSVC
char a[sizeof(B35)];
#else
B35 a;
#endif
};
#pragma pack()
struct B35_extra_required_alignment {
char a;
struct B35_extra_packed b;
};
struct B35_extra_required_alignment var303;
struct B35_extra_size {
char a[sizeof(B35)+1];
char b;
};
struct B35_extra_size var304;
#pragma pack(36)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B36;
B36 var305;
#pragma pack()
struct B36_extra_alignment {
char a;
B36 b;
};
struct B36_extra_alignment var306;
#pragma pack(1)
struct B36_extra_packed {
#ifdef MSVC
char a[sizeof(B36)];
#else
B36 a;
#endif
};
#pragma pack()
struct B36_extra_required_alignment {
char a;
struct B36_extra_packed b;
};
struct B36_extra_required_alignment var307;
struct B36_extra_size {
char a[sizeof(B36)+1];
char b;
};
struct B36_extra_size var308;
#pragma pack(37)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B37;
B37 var309;
#pragma pack()
struct B37_extra_alignment {
char a;
B37 b;
};
struct B37_extra_alignment var310;
#pragma pack(1)
struct B37_extra_packed {
#ifdef MSVC
char a[sizeof(B37)];
#else
B37 a;
#endif
};
#pragma pack()
struct B37_extra_required_alignment {
char a;
struct B37_extra_packed b;
};
struct B37_extra_required_alignment var311;
struct B37_extra_size {
char a[sizeof(B37)+1];
char b;
};
struct B37_extra_size var312;
#pragma pack(38)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B38;
B38 var313;
#pragma pack()
struct B38_extra_alignment {
char a;
B38 b;
};
struct B38_extra_alignment var314;
#pragma pack(1)
struct B38_extra_packed {
#ifdef MSVC
char a[sizeof(B38)];
#else
B38 a;
#endif
};
#pragma pack()
struct B38_extra_required_alignment {
char a;
struct B38_extra_packed b;
};
struct B38_extra_required_alignment var315;
struct B38_extra_size {
char a[sizeof(B38)+1];
char b;
};
struct B38_extra_size var316;
#pragma pack(39)
typedef union {
#ifdef MSVC
__declspec(align(128)) long long l;
#else
long long l __attribute__((aligned(128)));
#endif
} B39;
B39 var317;
#pragma pack()
struct B39_extra_alignment {
char a;
B39 b;
};
struct B39_extra_alignment var318;
#pragma pack(1)
struct B39_extra_packed {
#ifdef MSVC
char a[sizeof(B39)];
#else
B39 a;
#endif
};
#pragma pack()
struct B39_extra_required_alignment {
char a;
struct B39_extra_packed b;
};
struct B39_extra_required_alignment var319;
struct B39_extra_size {
char a[sizeof(B39)+1];
char b;
};
struct B39_extra_size var320;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-i686-windows-gnu:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I686PcWindowsGnu|Some("x86-i686-windows-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A00) == 128, "");
_Static_assert(_Alignof(A00) == 128, "");
_Static_assert(sizeof(struct A00_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A00_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A00_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A00_extra_packed) == 1, "");
_Static_assert(sizeof(struct A00_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A00_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A00_extra_size) == 130, "");
_Static_assert(_Alignof(struct A00_extra_size) == 1, "");
_Static_assert(sizeof(A01) == 8, "");
_Static_assert(_Alignof(A01) == 1, "");
_Static_assert(sizeof(struct A01_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A01_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A01_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A01_extra_packed) == 1, "");
_Static_assert(sizeof(struct A01_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A01_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A01_extra_size) == 10, "");
_Static_assert(_Alignof(struct A01_extra_size) == 1, "");
_Static_assert(sizeof(A02) == 8, "");
_Static_assert(_Alignof(A02) == 2, "");
_Static_assert(sizeof(struct A02_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A02_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A02_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A02_extra_packed) == 1, "");
_Static_assert(sizeof(struct A02_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A02_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A02_extra_size) == 10, "");
_Static_assert(_Alignof(struct A02_extra_size) == 1, "");
_Static_assert(sizeof(A03) == 128, "");
_Static_assert(_Alignof(A03) == 128, "");
_Static_assert(sizeof(struct A03_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A03_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A03_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A03_extra_packed) == 1, "");
_Static_assert(sizeof(struct A03_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A03_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A03_extra_size) == 130, "");
_Static_assert(_Alignof(struct A03_extra_size) == 1, "");
_Static_assert(sizeof(A04) == 8, "");
_Static_assert(_Alignof(A04) == 4, "");
_Static_assert(sizeof(struct A04_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A04_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A04_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A04_extra_packed) == 1, "");
_Static_assert(sizeof(struct A04_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A04_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A04_extra_size) == 10, "");
_Static_assert(_Alignof(struct A04_extra_size) == 1, "");
_Static_assert(sizeof(A05) == 128, "");
_Static_assert(_Alignof(A05) == 128, "");
_Static_assert(sizeof(struct A05_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A05_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A05_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A05_extra_packed) == 1, "");
_Static_assert(sizeof(struct A05_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A05_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A05_extra_size) == 130, "");
_Static_assert(_Alignof(struct A05_extra_size) == 1, "");
_Static_assert(sizeof(A06) == 128, "");
_Static_assert(_Alignof(A06) == 128, "");
_Static_assert(sizeof(struct A06_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A06_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A06_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A06_extra_packed) == 1, "");
_Static_assert(sizeof(struct A06_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A06_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A06_extra_size) == 130, "");
_Static_assert(_Alignof(struct A06_extra_size) == 1, "");
_Static_assert(sizeof(A07) == 128, "");
_Static_assert(_Alignof(A07) == 128, "");
_Static_assert(sizeof(struct A07_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A07_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A07_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A07_extra_packed) == 1, "");
_Static_assert(sizeof(struct A07_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A07_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A07_extra_size) == 130, "");
_Static_assert(_Alignof(struct A07_extra_size) == 1, "");
_Static_assert(sizeof(A08) == 8, "");
_Static_assert(_Alignof(A08) == 8, "");
_Static_assert(sizeof(struct A08_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A08_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A08_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A08_extra_packed) == 1, "");
_Static_assert(sizeof(struct A08_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A08_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A08_extra_size) == 10, "");
_Static_assert(_Alignof(struct A08_extra_size) == 1, "");
_Static_assert(sizeof(A09) == 128, "");
_Static_assert(_Alignof(A09) == 128, "");
_Static_assert(sizeof(struct A09_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A09_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A09_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A09_extra_packed) == 1, "");
_Static_assert(sizeof(struct A09_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A09_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A09_extra_size) == 130, "");
_Static_assert(_Alignof(struct A09_extra_size) == 1, "");
_Static_assert(sizeof(A10) == 128, "");
_Static_assert(_Alignof(A10) == 128, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A10_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 130, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 128, "");
_Static_assert(_Alignof(A11) == 128, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A11_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 130, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
_Static_assert(sizeof(A12) == 128, "");
_Static_assert(_Alignof(A12) == 128, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A12_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 130, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
_Static_assert(sizeof(A13) == 128, "");
_Static_assert(_Alignof(A13) == 128, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A13_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 130, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
_Static_assert(sizeof(A14) == 128, "");
_Static_assert(_Alignof(A14) == 128, "");
_Static_assert(sizeof(struct A14_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A14_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A14_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A14_extra_packed) == 1, "");
_Static_assert(sizeof(struct A14_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A14_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A14_extra_size) == 130, "");
_Static_assert(_Alignof(struct A14_extra_size) == 1, "");
_Static_assert(sizeof(A15) == 128, "");
_Static_assert(_Alignof(A15) == 128, "");
_Static_assert(sizeof(struct A15_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A15_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A15_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A15_extra_packed) == 1, "");
_Static_assert(sizeof(struct A15_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A15_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A15_extra_size) == 130, "");
_Static_assert(_Alignof(struct A15_extra_size) == 1, "");
_Static_assert(sizeof(A16) == 16, "");
_Static_assert(_Alignof(A16) == 16, "");
_Static_assert(sizeof(struct A16_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A16_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A16_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A16_extra_packed) == 1, "");
_Static_assert(sizeof(struct A16_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A16_extra_size) == 18, "");
_Static_assert(_Alignof(struct A16_extra_size) == 1, "");
_Static_assert(sizeof(A17) == 128, "");
_Static_assert(_Alignof(A17) == 128, "");
_Static_assert(sizeof(struct A17_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A17_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A17_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A17_extra_packed) == 1, "");
_Static_assert(sizeof(struct A17_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A17_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A17_extra_size) == 130, "");
_Static_assert(_Alignof(struct A17_extra_size) == 1, "");
_Static_assert(sizeof(A18) == 128, "");
_Static_assert(_Alignof(A18) == 128, "");
_Static_assert(sizeof(struct A18_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A18_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A18_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A18_extra_packed) == 1, "");
_Static_assert(sizeof(struct A18_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A18_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A18_extra_size) == 130, "");
_Static_assert(_Alignof(struct A18_extra_size) == 1, "");
_Static_assert(sizeof(A19) == 128, "");
_Static_assert(_Alignof(A19) == 128, "");
_Static_assert(sizeof(struct A19_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A19_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A19_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A19_extra_packed) == 1, "");
_Static_assert(sizeof(struct A19_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A19_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A19_extra_size) == 130, "");
_Static_assert(_Alignof(struct A19_extra_size) == 1, "");
_Static_assert(sizeof(A20) == 128, "");
_Static_assert(_Alignof(A20) == 128, "");
_Static_assert(sizeof(struct A20_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A20_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A20_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A20_extra_packed) == 1, "");
_Static_assert(sizeof(struct A20_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A20_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A20_extra_size) == 130, "");
_Static_assert(_Alignof(struct A20_extra_size) == 1, "");
_Static_assert(sizeof(A21) == 128, "");
_Static_assert(_Alignof(A21) == 128, "");
_Static_assert(sizeof(struct A21_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A21_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A21_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A21_extra_packed) == 1, "");
_Static_assert(sizeof(struct A21_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A21_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A21_extra_size) == 130, "");
_Static_assert(_Alignof(struct A21_extra_size) == 1, "");
_Static_assert(sizeof(A22) == 128, "");
_Static_assert(_Alignof(A22) == 128, "");
_Static_assert(sizeof(struct A22_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A22_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A22_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A22_extra_packed) == 1, "");
_Static_assert(sizeof(struct A22_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A22_extra_size) == 130, "");
_Static_assert(_Alignof(struct A22_extra_size) == 1, "");
_Static_assert(sizeof(A23) == 128, "");
_Static_assert(_Alignof(A23) == 128, "");
_Static_assert(sizeof(struct A23_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A23_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A23_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A23_extra_packed) == 1, "");
_Static_assert(sizeof(struct A23_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A23_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A23_extra_size) == 130, "");
_Static_assert(_Alignof(struct A23_extra_size) == 1, "");
_Static_assert(sizeof(A24) == 128, "");
_Static_assert(_Alignof(A24) == 128, "");
_Static_assert(sizeof(struct A24_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A24_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A24_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A24_extra_packed) == 1, "");
_Static_assert(sizeof(struct A24_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A24_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A24_extra_size) == 130, "");
_Static_assert(_Alignof(struct A24_extra_size) == 1, "");
_Static_assert(sizeof(A25) == 128, "");
_Static_assert(_Alignof(A25) == 128, "");
_Static_assert(sizeof(struct A25_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A25_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A25_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A25_extra_packed) == 1, "");
_Static_assert(sizeof(struct A25_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A25_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A25_extra_size) == 130, "");
_Static_assert(_Alignof(struct A25_extra_size) == 1, "");
_Static_assert(sizeof(A26) == 128, "");
_Static_assert(_Alignof(A26) == 128, "");
_Static_assert(sizeof(struct A26_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A26_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A26_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A26_extra_packed) == 1, "");
_Static_assert(sizeof(struct A26_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A26_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A26_extra_size) == 130, "");
_Static_assert(_Alignof(struct A26_extra_size) == 1, "");
_Static_assert(sizeof(A27) == 128, "");
_Static_assert(_Alignof(A27) == 128, "");
_Static_assert(sizeof(struct A27_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A27_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A27_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A27_extra_packed) == 1, "");
_Static_assert(sizeof(struct A27_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A27_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A27_extra_size) == 130, "");
_Static_assert(_Alignof(struct A27_extra_size) == 1, "");
_Static_assert(sizeof(A28) == 128, "");
_Static_assert(_Alignof(A28) == 128, "");
_Static_assert(sizeof(struct A28_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A28_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A28_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A28_extra_packed) == 1, "");
_Static_assert(sizeof(struct A28_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A28_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A28_extra_size) == 130, "");
_Static_assert(_Alignof(struct A28_extra_size) == 1, "");
_Static_assert(sizeof(A29) == 128, "");
_Static_assert(_Alignof(A29) == 128, "");
_Static_assert(sizeof(struct A29_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A29_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A29_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A29_extra_packed) == 1, "");
_Static_assert(sizeof(struct A29_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A29_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A29_extra_size) == 130, "");
_Static_assert(_Alignof(struct A29_extra_size) == 1, "");
_Static_assert(sizeof(A30) == 128, "");
_Static_assert(_Alignof(A30) == 128, "");
_Static_assert(sizeof(struct A30_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A30_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A30_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A30_extra_packed) == 1, "");
_Static_assert(sizeof(struct A30_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A30_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A30_extra_size) == 130, "");
_Static_assert(_Alignof(struct A30_extra_size) == 1, "");
_Static_assert(sizeof(A31) == 128, "");
_Static_assert(_Alignof(A31) == 128, "");
_Static_assert(sizeof(struct A31_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A31_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A31_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A31_extra_packed) == 1, "");
_Static_assert(sizeof(struct A31_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A31_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A31_extra_size) == 130, "");
_Static_assert(_Alignof(struct A31_extra_size) == 1, "");
_Static_assert(sizeof(A32) == 128, "");
_Static_assert(_Alignof(A32) == 128, "");
_Static_assert(sizeof(struct A32_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A32_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A32_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A32_extra_packed) == 1, "");
_Static_assert(sizeof(struct A32_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A32_extra_size) == 130, "");
_Static_assert(_Alignof(struct A32_extra_size) == 1, "");
_Static_assert(sizeof(A33) == 128, "");
_Static_assert(_Alignof(A33) == 128, "");
_Static_assert(sizeof(struct A33_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A33_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A33_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A33_extra_packed) == 1, "");
_Static_assert(sizeof(struct A33_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A33_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A33_extra_size) == 130, "");
_Static_assert(_Alignof(struct A33_extra_size) == 1, "");
_Static_assert(sizeof(A34) == 128, "");
_Static_assert(_Alignof(A34) == 128, "");
_Static_assert(sizeof(struct A34_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A34_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A34_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A34_extra_packed) == 1, "");
_Static_assert(sizeof(struct A34_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A34_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A34_extra_size) == 130, "");
_Static_assert(_Alignof(struct A34_extra_size) == 1, "");
_Static_assert(sizeof(A35) == 128, "");
_Static_assert(_Alignof(A35) == 128, "");
_Static_assert(sizeof(struct A35_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A35_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A35_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A35_extra_packed) == 1, "");
_Static_assert(sizeof(struct A35_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A35_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A35_extra_size) == 130, "");
_Static_assert(_Alignof(struct A35_extra_size) == 1, "");
_Static_assert(sizeof(A36) == 128, "");
_Static_assert(_Alignof(A36) == 128, "");
_Static_assert(sizeof(struct A36_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A36_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A36_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A36_extra_packed) == 1, "");
_Static_assert(sizeof(struct A36_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A36_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A36_extra_size) == 130, "");
_Static_assert(_Alignof(struct A36_extra_size) == 1, "");
_Static_assert(sizeof(A37) == 128, "");
_Static_assert(_Alignof(A37) == 128, "");
_Static_assert(sizeof(struct A37_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A37_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A37_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A37_extra_packed) == 1, "");
_Static_assert(sizeof(struct A37_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A37_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A37_extra_size) == 130, "");
_Static_assert(_Alignof(struct A37_extra_size) == 1, "");
_Static_assert(sizeof(A38) == 128, "");
_Static_assert(_Alignof(A38) == 128, "");
_Static_assert(sizeof(struct A38_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A38_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A38_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A38_extra_packed) == 1, "");
_Static_assert(sizeof(struct A38_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A38_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A38_extra_size) == 130, "");
_Static_assert(_Alignof(struct A38_extra_size) == 1, "");
_Static_assert(sizeof(A39) == 128, "");
_Static_assert(_Alignof(A39) == 128, "");
_Static_assert(sizeof(struct A39_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A39_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A39_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A39_extra_packed) == 1, "");
_Static_assert(sizeof(struct A39_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A39_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A39_extra_size) == 130, "");
_Static_assert(_Alignof(struct A39_extra_size) == 1, "");
_Static_assert(sizeof(B00) == 128, "");
_Static_assert(_Alignof(B00) == 128, "");
_Static_assert(sizeof(struct B00_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B00_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B00_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B00_extra_packed) == 1, "");
_Static_assert(sizeof(struct B00_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B00_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B00_extra_size) == 130, "");
_Static_assert(_Alignof(struct B00_extra_size) == 1, "");
_Static_assert(sizeof(B01) == 8, "");
_Static_assert(_Alignof(B01) == 1, "");
_Static_assert(sizeof(struct B01_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B01_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B01_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B01_extra_packed) == 1, "");
_Static_assert(sizeof(struct B01_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B01_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B01_extra_size) == 10, "");
_Static_assert(_Alignof(struct B01_extra_size) == 1, "");
_Static_assert(sizeof(B02) == 8, "");
_Static_assert(_Alignof(B02) == 2, "");
_Static_assert(sizeof(struct B02_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B02_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B02_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B02_extra_packed) == 1, "");
_Static_assert(sizeof(struct B02_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B02_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B02_extra_size) == 10, "");
_Static_assert(_Alignof(struct B02_extra_size) == 1, "");
_Static_assert(sizeof(B03) == 128, "");
_Static_assert(_Alignof(B03) == 128, "");
_Static_assert(sizeof(struct B03_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B03_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B03_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B03_extra_packed) == 1, "");
_Static_assert(sizeof(struct B03_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B03_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B03_extra_size) == 130, "");
_Static_assert(_Alignof(struct B03_extra_size) == 1, "");
_Static_assert(sizeof(B04) == 8, "");
_Static_assert(_Alignof(B04) == 4, "");
_Static_assert(sizeof(struct B04_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B04_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B04_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B04_extra_packed) == 1, "");
_Static_assert(sizeof(struct B04_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B04_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B04_extra_size) == 10, "");
_Static_assert(_Alignof(struct B04_extra_size) == 1, "");
_Static_assert(sizeof(B05) == 128, "");
_Static_assert(_Alignof(B05) == 128, "");
_Static_assert(sizeof(struct B05_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B05_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B05_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B05_extra_packed) == 1, "");
_Static_assert(sizeof(struct B05_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B05_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B05_extra_size) == 130, "");
_Static_assert(_Alignof(struct B05_extra_size) == 1, "");
_Static_assert(sizeof(B06) == 128, "");
_Static_assert(_Alignof(B06) == 128, "");
_Static_assert(sizeof(struct B06_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B06_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B06_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B06_extra_packed) == 1, "");
_Static_assert(sizeof(struct B06_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B06_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B06_extra_size) == 130, "");
_Static_assert(_Alignof(struct B06_extra_size) == 1, "");
_Static_assert(sizeof(B07) == 128, "");
_Static_assert(_Alignof(B07) == 128, "");
_Static_assert(sizeof(struct B07_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B07_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B07_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B07_extra_packed) == 1, "");
_Static_assert(sizeof(struct B07_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B07_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B07_extra_size) == 130, "");
_Static_assert(_Alignof(struct B07_extra_size) == 1, "");
_Static_assert(sizeof(B08) == 8, "");
_Static_assert(_Alignof(B08) == 8, "");
_Static_assert(sizeof(struct B08_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B08_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B08_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B08_extra_packed) == 1, "");
_Static_assert(sizeof(struct B08_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B08_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B08_extra_size) == 10, "");
_Static_assert(_Alignof(struct B08_extra_size) == 1, "");
_Static_assert(sizeof(B09) == 128, "");
_Static_assert(_Alignof(B09) == 128, "");
_Static_assert(sizeof(struct B09_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B09_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B09_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B09_extra_packed) == 1, "");
_Static_assert(sizeof(struct B09_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B09_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B09_extra_size) == 130, "");
_Static_assert(_Alignof(struct B09_extra_size) == 1, "");
_Static_assert(sizeof(B10) == 128, "");
_Static_assert(_Alignof(B10) == 128, "");
_Static_assert(sizeof(struct B10_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B10_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B10_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B10_extra_packed) == 1, "");
_Static_assert(sizeof(struct B10_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B10_extra_size) == 130, "");
_Static_assert(_Alignof(struct B10_extra_size) == 1, "");
_Static_assert(sizeof(B11) == 128, "");
_Static_assert(_Alignof(B11) == 128, "");
_Static_assert(sizeof(struct B11_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B11_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B11_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B11_extra_packed) == 1, "");
_Static_assert(sizeof(struct B11_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B11_extra_size) == 130, "");
_Static_assert(_Alignof(struct B11_extra_size) == 1, "");
_Static_assert(sizeof(B12) == 128, "");
_Static_assert(_Alignof(B12) == 128, "");
_Static_assert(sizeof(struct B12_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B12_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B12_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B12_extra_packed) == 1, "");
_Static_assert(sizeof(struct B12_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B12_extra_size) == 130, "");
_Static_assert(_Alignof(struct B12_extra_size) == 1, "");
_Static_assert(sizeof(B13) == 128, "");
_Static_assert(_Alignof(B13) == 128, "");
_Static_assert(sizeof(struct B13_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B13_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B13_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B13_extra_packed) == 1, "");
_Static_assert(sizeof(struct B13_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B13_extra_size) == 130, "");
_Static_assert(_Alignof(struct B13_extra_size) == 1, "");
_Static_assert(sizeof(B14) == 128, "");
_Static_assert(_Alignof(B14) == 128, "");
_Static_assert(sizeof(struct B14_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B14_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B14_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B14_extra_packed) == 1, "");
_Static_assert(sizeof(struct B14_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B14_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B14_extra_size) == 130, "");
_Static_assert(_Alignof(struct B14_extra_size) == 1, "");
_Static_assert(sizeof(B15) == 128, "");
_Static_assert(_Alignof(B15) == 128, "");
_Static_assert(sizeof(struct B15_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B15_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B15_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B15_extra_packed) == 1, "");
_Static_assert(sizeof(struct B15_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B15_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B15_extra_size) == 130, "");
_Static_assert(_Alignof(struct B15_extra_size) == 1, "");
_Static_assert(sizeof(B16) == 16, "");
_Static_assert(_Alignof(B16) == 16, "");
_Static_assert(sizeof(struct B16_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B16_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B16_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B16_extra_packed) == 1, "");
_Static_assert(sizeof(struct B16_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B16_extra_size) == 18, "");
_Static_assert(_Alignof(struct B16_extra_size) == 1, "");
_Static_assert(sizeof(B17) == 128, "");
_Static_assert(_Alignof(B17) == 128, "");
_Static_assert(sizeof(struct B17_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B17_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B17_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B17_extra_packed) == 1, "");
_Static_assert(sizeof(struct B17_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B17_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B17_extra_size) == 130, "");
_Static_assert(_Alignof(struct B17_extra_size) == 1, "");
_Static_assert(sizeof(B18) == 128, "");
_Static_assert(_Alignof(B18) == 128, "");
_Static_assert(sizeof(struct B18_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B18_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B18_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B18_extra_packed) == 1, "");
_Static_assert(sizeof(struct B18_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B18_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B18_extra_size) == 130, "");
_Static_assert(_Alignof(struct B18_extra_size) == 1, "");
_Static_assert(sizeof(B19) == 128, "");
_Static_assert(_Alignof(B19) == 128, "");
_Static_assert(sizeof(struct B19_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B19_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B19_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B19_extra_packed) == 1, "");
_Static_assert(sizeof(struct B19_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B19_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B19_extra_size) == 130, "");
_Static_assert(_Alignof(struct B19_extra_size) == 1, "");
_Static_assert(sizeof(B20) == 128, "");
_Static_assert(_Alignof(B20) == 128, "");
_Static_assert(sizeof(struct B20_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B20_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B20_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B20_extra_packed) == 1, "");
_Static_assert(sizeof(struct B20_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B20_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B20_extra_size) == 130, "");
_Static_assert(_Alignof(struct B20_extra_size) == 1, "");
_Static_assert(sizeof(B21) == 128, "");
_Static_assert(_Alignof(B21) == 128, "");
_Static_assert(sizeof(struct B21_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B21_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B21_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B21_extra_packed) == 1, "");
_Static_assert(sizeof(struct B21_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B21_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B21_extra_size) == 130, "");
_Static_assert(_Alignof(struct B21_extra_size) == 1, "");
_Static_assert(sizeof(B22) == 128, "");
_Static_assert(_Alignof(B22) == 128, "");
_Static_assert(sizeof(struct B22_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B22_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B22_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B22_extra_packed) == 1, "");
_Static_assert(sizeof(struct B22_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B22_extra_size) == 130, "");
_Static_assert(_Alignof(struct B22_extra_size) == 1, "");
_Static_assert(sizeof(B23) == 128, "");
_Static_assert(_Alignof(B23) == 128, "");
_Static_assert(sizeof(struct B23_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B23_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B23_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B23_extra_packed) == 1, "");
_Static_assert(sizeof(struct B23_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B23_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B23_extra_size) == 130, "");
_Static_assert(_Alignof(struct B23_extra_size) == 1, "");
_Static_assert(sizeof(B24) == 128, "");
_Static_assert(_Alignof(B24) == 128, "");
_Static_assert(sizeof(struct B24_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B24_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B24_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B24_extra_packed) == 1, "");
_Static_assert(sizeof(struct B24_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B24_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B24_extra_size) == 130, "");
_Static_assert(_Alignof(struct B24_extra_size) == 1, "");
_Static_assert(sizeof(B25) == 128, "");
_Static_assert(_Alignof(B25) == 128, "");
_Static_assert(sizeof(struct B25_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B25_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B25_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B25_extra_packed) == 1, "");
_Static_assert(sizeof(struct B25_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B25_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B25_extra_size) == 130, "");
_Static_assert(_Alignof(struct B25_extra_size) == 1, "");
_Static_assert(sizeof(B26) == 128, "");
_Static_assert(_Alignof(B26) == 128, "");
_Static_assert(sizeof(struct B26_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B26_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B26_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B26_extra_packed) == 1, "");
_Static_assert(sizeof(struct B26_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B26_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B26_extra_size) == 130, "");
_Static_assert(_Alignof(struct B26_extra_size) == 1, "");
_Static_assert(sizeof(B27) == 128, "");
_Static_assert(_Alignof(B27) == 128, "");
_Static_assert(sizeof(struct B27_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B27_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B27_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B27_extra_packed) == 1, "");
_Static_assert(sizeof(struct B27_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B27_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B27_extra_size) == 130, "");
_Static_assert(_Alignof(struct B27_extra_size) == 1, "");
_Static_assert(sizeof(B28) == 128, "");
_Static_assert(_Alignof(B28) == 128, "");
_Static_assert(sizeof(struct B28_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B28_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B28_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B28_extra_packed) == 1, "");
_Static_assert(sizeof(struct B28_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B28_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B28_extra_size) == 130, "");
_Static_assert(_Alignof(struct B28_extra_size) == 1, "");
_Static_assert(sizeof(B29) == 128, "");
_Static_assert(_Alignof(B29) == 128, "");
_Static_assert(sizeof(struct B29_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B29_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B29_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B29_extra_packed) == 1, "");
_Static_assert(sizeof(struct B29_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B29_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B29_extra_size) == 130, "");
_Static_assert(_Alignof(struct B29_extra_size) == 1, "");
_Static_assert(sizeof(B30) == 128, "");
_Static_assert(_Alignof(B30) == 128, "");
_Static_assert(sizeof(struct B30_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B30_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B30_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B30_extra_packed) == 1, "");
_Static_assert(sizeof(struct B30_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B30_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B30_extra_size) == 130, "");
_Static_assert(_Alignof(struct B30_extra_size) == 1, "");
_Static_assert(sizeof(B31) == 128, "");
_Static_assert(_Alignof(B31) == 128, "");
_Static_assert(sizeof(struct B31_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B31_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B31_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B31_extra_packed) == 1, "");
_Static_assert(sizeof(struct B31_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B31_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B31_extra_size) == 130, "");
_Static_assert(_Alignof(struct B31_extra_size) == 1, "");
_Static_assert(sizeof(B32) == 128, "");
_Static_assert(_Alignof(B32) == 128, "");
_Static_assert(sizeof(struct B32_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B32_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B32_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B32_extra_packed) == 1, "");
_Static_assert(sizeof(struct B32_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B32_extra_size) == 130, "");
_Static_assert(_Alignof(struct B32_extra_size) == 1, "");
_Static_assert(sizeof(B33) == 128, "");
_Static_assert(_Alignof(B33) == 128, "");
_Static_assert(sizeof(struct B33_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B33_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B33_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B33_extra_packed) == 1, "");
_Static_assert(sizeof(struct B33_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B33_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B33_extra_size) == 130, "");
_Static_assert(_Alignof(struct B33_extra_size) == 1, "");
_Static_assert(sizeof(B34) == 128, "");
_Static_assert(_Alignof(B34) == 128, "");
_Static_assert(sizeof(struct B34_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B34_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B34_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B34_extra_packed) == 1, "");
_Static_assert(sizeof(struct B34_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B34_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B34_extra_size) == 130, "");
_Static_assert(_Alignof(struct B34_extra_size) == 1, "");
_Static_assert(sizeof(B35) == 128, "");
_Static_assert(_Alignof(B35) == 128, "");
_Static_assert(sizeof(struct B35_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B35_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B35_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B35_extra_packed) == 1, "");
_Static_assert(sizeof(struct B35_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B35_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B35_extra_size) == 130, "");
_Static_assert(_Alignof(struct B35_extra_size) == 1, "");
_Static_assert(sizeof(B36) == 128, "");
_Static_assert(_Alignof(B36) == 128, "");
_Static_assert(sizeof(struct B36_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B36_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B36_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B36_extra_packed) == 1, "");
_Static_assert(sizeof(struct B36_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B36_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B36_extra_size) == 130, "");
_Static_assert(_Alignof(struct B36_extra_size) == 1, "");
_Static_assert(sizeof(B37) == 128, "");
_Static_assert(_Alignof(B37) == 128, "");
_Static_assert(sizeof(struct B37_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B37_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B37_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B37_extra_packed) == 1, "");
_Static_assert(sizeof(struct B37_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B37_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B37_extra_size) == 130, "");
_Static_assert(_Alignof(struct B37_extra_size) == 1, "");
_Static_assert(sizeof(B38) == 128, "");
_Static_assert(_Alignof(B38) == 128, "");
_Static_assert(sizeof(struct B38_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B38_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B38_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B38_extra_packed) == 1, "");
_Static_assert(sizeof(struct B38_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B38_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B38_extra_size) == 130, "");
_Static_assert(_Alignof(struct B38_extra_size) == 1, "");
_Static_assert(sizeof(B39) == 128, "");
_Static_assert(_Alignof(B39) == 128, "");
_Static_assert(sizeof(struct B39_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B39_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B39_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B39_extra_packed) == 1, "");
_Static_assert(sizeof(struct B39_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B39_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B39_extra_size) == 130, "");
_Static_assert(_Alignof(struct B39_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A00) == 128, "");
_Static_assert(_Alignof(A00) == 128, "");
_Static_assert(sizeof(struct A00_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A00_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A00_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A00_extra_packed) == 1, "");
_Static_assert(sizeof(struct A00_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A00_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A00_extra_size) == 130, "");
_Static_assert(_Alignof(struct A00_extra_size) == 1, "");
_Static_assert(sizeof(A01) == 128, "");
_Static_assert(_Alignof(A01) == 128, "");
_Static_assert(sizeof(struct A01_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A01_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A01_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A01_extra_packed) == 1, "");
_Static_assert(sizeof(struct A01_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A01_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A01_extra_size) == 130, "");
_Static_assert(_Alignof(struct A01_extra_size) == 1, "");
_Static_assert(sizeof(A02) == 128, "");
_Static_assert(_Alignof(A02) == 128, "");
_Static_assert(sizeof(struct A02_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A02_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A02_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A02_extra_packed) == 1, "");
_Static_assert(sizeof(struct A02_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A02_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A02_extra_size) == 130, "");
_Static_assert(_Alignof(struct A02_extra_size) == 1, "");
_Static_assert(sizeof(A03) == 128, "");
_Static_assert(_Alignof(A03) == 128, "");
_Static_assert(sizeof(struct A03_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A03_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A03_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A03_extra_packed) == 1, "");
_Static_assert(sizeof(struct A03_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A03_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A03_extra_size) == 130, "");
_Static_assert(_Alignof(struct A03_extra_size) == 1, "");
_Static_assert(sizeof(A04) == 128, "");
_Static_assert(_Alignof(A04) == 128, "");
_Static_assert(sizeof(struct A04_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A04_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A04_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A04_extra_packed) == 1, "");
_Static_assert(sizeof(struct A04_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A04_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A04_extra_size) == 130, "");
_Static_assert(_Alignof(struct A04_extra_size) == 1, "");
_Static_assert(sizeof(A05) == 128, "");
_Static_assert(_Alignof(A05) == 128, "");
_Static_assert(sizeof(struct A05_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A05_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A05_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A05_extra_packed) == 1, "");
_Static_assert(sizeof(struct A05_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A05_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A05_extra_size) == 130, "");
_Static_assert(_Alignof(struct A05_extra_size) == 1, "");
_Static_assert(sizeof(A06) == 128, "");
_Static_assert(_Alignof(A06) == 128, "");
_Static_assert(sizeof(struct A06_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A06_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A06_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A06_extra_packed) == 1, "");
_Static_assert(sizeof(struct A06_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A06_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A06_extra_size) == 130, "");
_Static_assert(_Alignof(struct A06_extra_size) == 1, "");
_Static_assert(sizeof(A07) == 128, "");
_Static_assert(_Alignof(A07) == 128, "");
_Static_assert(sizeof(struct A07_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A07_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A07_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A07_extra_packed) == 1, "");
_Static_assert(sizeof(struct A07_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A07_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A07_extra_size) == 130, "");
_Static_assert(_Alignof(struct A07_extra_size) == 1, "");
_Static_assert(sizeof(A08) == 128, "");
_Static_assert(_Alignof(A08) == 128, "");
_Static_assert(sizeof(struct A08_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A08_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A08_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A08_extra_packed) == 1, "");
_Static_assert(sizeof(struct A08_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A08_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A08_extra_size) == 130, "");
_Static_assert(_Alignof(struct A08_extra_size) == 1, "");
_Static_assert(sizeof(A09) == 128, "");
_Static_assert(_Alignof(A09) == 128, "");
_Static_assert(sizeof(struct A09_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A09_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A09_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A09_extra_packed) == 1, "");
_Static_assert(sizeof(struct A09_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A09_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A09_extra_size) == 130, "");
_Static_assert(_Alignof(struct A09_extra_size) == 1, "");
_Static_assert(sizeof(A10) == 128, "");
_Static_assert(_Alignof(A10) == 128, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A10_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 130, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 128, "");
_Static_assert(_Alignof(A11) == 128, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A11_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 130, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
_Static_assert(sizeof(A12) == 128, "");
_Static_assert(_Alignof(A12) == 128, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A12_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 130, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
_Static_assert(sizeof(A13) == 128, "");
_Static_assert(_Alignof(A13) == 128, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A13_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 130, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
_Static_assert(sizeof(A14) == 128, "");
_Static_assert(_Alignof(A14) == 128, "");
_Static_assert(sizeof(struct A14_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A14_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A14_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A14_extra_packed) == 1, "");
_Static_assert(sizeof(struct A14_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A14_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A14_extra_size) == 130, "");
_Static_assert(_Alignof(struct A14_extra_size) == 1, "");
_Static_assert(sizeof(A15) == 128, "");
_Static_assert(_Alignof(A15) == 128, "");
_Static_assert(sizeof(struct A15_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A15_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A15_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A15_extra_packed) == 1, "");
_Static_assert(sizeof(struct A15_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A15_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A15_extra_size) == 130, "");
_Static_assert(_Alignof(struct A15_extra_size) == 1, "");
_Static_assert(sizeof(A16) == 128, "");
_Static_assert(_Alignof(A16) == 128, "");
_Static_assert(sizeof(struct A16_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A16_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A16_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A16_extra_packed) == 1, "");
_Static_assert(sizeof(struct A16_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A16_extra_size) == 130, "");
_Static_assert(_Alignof(struct A16_extra_size) == 1, "");
_Static_assert(sizeof(A17) == 128, "");
_Static_assert(_Alignof(A17) == 128, "");
_Static_assert(sizeof(struct A17_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A17_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A17_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A17_extra_packed) == 1, "");
_Static_assert(sizeof(struct A17_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A17_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A17_extra_size) == 130, "");
_Static_assert(_Alignof(struct A17_extra_size) == 1, "");
_Static_assert(sizeof(A18) == 128, "");
_Static_assert(_Alignof(A18) == 128, "");
_Static_assert(sizeof(struct A18_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A18_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A18_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A18_extra_packed) == 1, "");
_Static_assert(sizeof(struct A18_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A18_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A18_extra_size) == 130, "");
_Static_assert(_Alignof(struct A18_extra_size) == 1, "");
_Static_assert(sizeof(A19) == 128, "");
_Static_assert(_Alignof(A19) == 128, "");
_Static_assert(sizeof(struct A19_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A19_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A19_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A19_extra_packed) == 1, "");
_Static_assert(sizeof(struct A19_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A19_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A19_extra_size) == 130, "");
_Static_assert(_Alignof(struct A19_extra_size) == 1, "");
_Static_assert(sizeof(A20) == 128, "");
_Static_assert(_Alignof(A20) == 128, "");
_Static_assert(sizeof(struct A20_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A20_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A20_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A20_extra_packed) == 1, "");
_Static_assert(sizeof(struct A20_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A20_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A20_extra_size) == 130, "");
_Static_assert(_Alignof(struct A20_extra_size) == 1, "");
_Static_assert(sizeof(A21) == 128, "");
_Static_assert(_Alignof(A21) == 128, "");
_Static_assert(sizeof(struct A21_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A21_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A21_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A21_extra_packed) == 1, "");
_Static_assert(sizeof(struct A21_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A21_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A21_extra_size) == 130, "");
_Static_assert(_Alignof(struct A21_extra_size) == 1, "");
_Static_assert(sizeof(A22) == 128, "");
_Static_assert(_Alignof(A22) == 128, "");
_Static_assert(sizeof(struct A22_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A22_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A22_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A22_extra_packed) == 1, "");
_Static_assert(sizeof(struct A22_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A22_extra_size) == 130, "");
_Static_assert(_Alignof(struct A22_extra_size) == 1, "");
_Static_assert(sizeof(A23) == 128, "");
_Static_assert(_Alignof(A23) == 128, "");
_Static_assert(sizeof(struct A23_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A23_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A23_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A23_extra_packed) == 1, "");
_Static_assert(sizeof(struct A23_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A23_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A23_extra_size) == 130, "");
_Static_assert(_Alignof(struct A23_extra_size) == 1, "");
_Static_assert(sizeof(A24) == 128, "");
_Static_assert(_Alignof(A24) == 128, "");
_Static_assert(sizeof(struct A24_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A24_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A24_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A24_extra_packed) == 1, "");
_Static_assert(sizeof(struct A24_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A24_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A24_extra_size) == 130, "");
_Static_assert(_Alignof(struct A24_extra_size) == 1, "");
_Static_assert(sizeof(A25) == 128, "");
_Static_assert(_Alignof(A25) == 128, "");
_Static_assert(sizeof(struct A25_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A25_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A25_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A25_extra_packed) == 1, "");
_Static_assert(sizeof(struct A25_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A25_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A25_extra_size) == 130, "");
_Static_assert(_Alignof(struct A25_extra_size) == 1, "");
_Static_assert(sizeof(A26) == 128, "");
_Static_assert(_Alignof(A26) == 128, "");
_Static_assert(sizeof(struct A26_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A26_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A26_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A26_extra_packed) == 1, "");
_Static_assert(sizeof(struct A26_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A26_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A26_extra_size) == 130, "");
_Static_assert(_Alignof(struct A26_extra_size) == 1, "");
_Static_assert(sizeof(A27) == 128, "");
_Static_assert(_Alignof(A27) == 128, "");
_Static_assert(sizeof(struct A27_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A27_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A27_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A27_extra_packed) == 1, "");
_Static_assert(sizeof(struct A27_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A27_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A27_extra_size) == 130, "");
_Static_assert(_Alignof(struct A27_extra_size) == 1, "");
_Static_assert(sizeof(A28) == 128, "");
_Static_assert(_Alignof(A28) == 128, "");
_Static_assert(sizeof(struct A28_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A28_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A28_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A28_extra_packed) == 1, "");
_Static_assert(sizeof(struct A28_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A28_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A28_extra_size) == 130, "");
_Static_assert(_Alignof(struct A28_extra_size) == 1, "");
_Static_assert(sizeof(A29) == 128, "");
_Static_assert(_Alignof(A29) == 128, "");
_Static_assert(sizeof(struct A29_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A29_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A29_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A29_extra_packed) == 1, "");
_Static_assert(sizeof(struct A29_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A29_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A29_extra_size) == 130, "");
_Static_assert(_Alignof(struct A29_extra_size) == 1, "");
_Static_assert(sizeof(A30) == 128, "");
_Static_assert(_Alignof(A30) == 128, "");
_Static_assert(sizeof(struct A30_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A30_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A30_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A30_extra_packed) == 1, "");
_Static_assert(sizeof(struct A30_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A30_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A30_extra_size) == 130, "");
_Static_assert(_Alignof(struct A30_extra_size) == 1, "");
_Static_assert(sizeof(A31) == 128, "");
_Static_assert(_Alignof(A31) == 128, "");
_Static_assert(sizeof(struct A31_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A31_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A31_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A31_extra_packed) == 1, "");
_Static_assert(sizeof(struct A31_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A31_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A31_extra_size) == 130, "");
_Static_assert(_Alignof(struct A31_extra_size) == 1, "");
_Static_assert(sizeof(A32) == 128, "");
_Static_assert(_Alignof(A32) == 128, "");
_Static_assert(sizeof(struct A32_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A32_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A32_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A32_extra_packed) == 1, "");
_Static_assert(sizeof(struct A32_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A32_extra_size) == 130, "");
_Static_assert(_Alignof(struct A32_extra_size) == 1, "");
_Static_assert(sizeof(A33) == 128, "");
_Static_assert(_Alignof(A33) == 128, "");
_Static_assert(sizeof(struct A33_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A33_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A33_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A33_extra_packed) == 1, "");
_Static_assert(sizeof(struct A33_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A33_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A33_extra_size) == 130, "");
_Static_assert(_Alignof(struct A33_extra_size) == 1, "");
_Static_assert(sizeof(A34) == 128, "");
_Static_assert(_Alignof(A34) == 128, "");
_Static_assert(sizeof(struct A34_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A34_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A34_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A34_extra_packed) == 1, "");
_Static_assert(sizeof(struct A34_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A34_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A34_extra_size) == 130, "");
_Static_assert(_Alignof(struct A34_extra_size) == 1, "");
_Static_assert(sizeof(A35) == 128, "");
_Static_assert(_Alignof(A35) == 128, "");
_Static_assert(sizeof(struct A35_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A35_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A35_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A35_extra_packed) == 1, "");
_Static_assert(sizeof(struct A35_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A35_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A35_extra_size) == 130, "");
_Static_assert(_Alignof(struct A35_extra_size) == 1, "");
_Static_assert(sizeof(A36) == 128, "");
_Static_assert(_Alignof(A36) == 128, "");
_Static_assert(sizeof(struct A36_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A36_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A36_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A36_extra_packed) == 1, "");
_Static_assert(sizeof(struct A36_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A36_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A36_extra_size) == 130, "");
_Static_assert(_Alignof(struct A36_extra_size) == 1, "");
_Static_assert(sizeof(A37) == 128, "");
_Static_assert(_Alignof(A37) == 128, "");
_Static_assert(sizeof(struct A37_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A37_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A37_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A37_extra_packed) == 1, "");
_Static_assert(sizeof(struct A37_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A37_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A37_extra_size) == 130, "");
_Static_assert(_Alignof(struct A37_extra_size) == 1, "");
_Static_assert(sizeof(A38) == 128, "");
_Static_assert(_Alignof(A38) == 128, "");
_Static_assert(sizeof(struct A38_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A38_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A38_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A38_extra_packed) == 1, "");
_Static_assert(sizeof(struct A38_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A38_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A38_extra_size) == 130, "");
_Static_assert(_Alignof(struct A38_extra_size) == 1, "");
_Static_assert(sizeof(A39) == 128, "");
_Static_assert(_Alignof(A39) == 128, "");
_Static_assert(sizeof(struct A39_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A39_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A39_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A39_extra_packed) == 1, "");
_Static_assert(sizeof(struct A39_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A39_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A39_extra_size) == 130, "");
_Static_assert(_Alignof(struct A39_extra_size) == 1, "");
_Static_assert(sizeof(B00) == 128, "");
_Static_assert(_Alignof(B00) == 128, "");
_Static_assert(sizeof(struct B00_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B00_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B00_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B00_extra_packed) == 1, "");
_Static_assert(sizeof(struct B00_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B00_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B00_extra_size) == 130, "");
_Static_assert(_Alignof(struct B00_extra_size) == 1, "");
_Static_assert(sizeof(B01) == 128, "");
_Static_assert(_Alignof(B01) == 128, "");
_Static_assert(sizeof(struct B01_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B01_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B01_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B01_extra_packed) == 1, "");
_Static_assert(sizeof(struct B01_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B01_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B01_extra_size) == 130, "");
_Static_assert(_Alignof(struct B01_extra_size) == 1, "");
_Static_assert(sizeof(B02) == 128, "");
_Static_assert(_Alignof(B02) == 128, "");
_Static_assert(sizeof(struct B02_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B02_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B02_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B02_extra_packed) == 1, "");
_Static_assert(sizeof(struct B02_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B02_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B02_extra_size) == 130, "");
_Static_assert(_Alignof(struct B02_extra_size) == 1, "");
_Static_assert(sizeof(B03) == 128, "");
_Static_assert(_Alignof(B03) == 128, "");
_Static_assert(sizeof(struct B03_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B03_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B03_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B03_extra_packed) == 1, "");
_Static_assert(sizeof(struct B03_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B03_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B03_extra_size) == 130, "");
_Static_assert(_Alignof(struct B03_extra_size) == 1, "");
_Static_assert(sizeof(B04) == 128, "");
_Static_assert(_Alignof(B04) == 128, "");
_Static_assert(sizeof(struct B04_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B04_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B04_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B04_extra_packed) == 1, "");
_Static_assert(sizeof(struct B04_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B04_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B04_extra_size) == 130, "");
_Static_assert(_Alignof(struct B04_extra_size) == 1, "");
_Static_assert(sizeof(B05) == 128, "");
_Static_assert(_Alignof(B05) == 128, "");
_Static_assert(sizeof(struct B05_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B05_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B05_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B05_extra_packed) == 1, "");
_Static_assert(sizeof(struct B05_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B05_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B05_extra_size) == 130, "");
_Static_assert(_Alignof(struct B05_extra_size) == 1, "");
_Static_assert(sizeof(B06) == 128, "");
_Static_assert(_Alignof(B06) == 128, "");
_Static_assert(sizeof(struct B06_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B06_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B06_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B06_extra_packed) == 1, "");
_Static_assert(sizeof(struct B06_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B06_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B06_extra_size) == 130, "");
_Static_assert(_Alignof(struct B06_extra_size) == 1, "");
_Static_assert(sizeof(B07) == 128, "");
_Static_assert(_Alignof(B07) == 128, "");
_Static_assert(sizeof(struct B07_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B07_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B07_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B07_extra_packed) == 1, "");
_Static_assert(sizeof(struct B07_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B07_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B07_extra_size) == 130, "");
_Static_assert(_Alignof(struct B07_extra_size) == 1, "");
_Static_assert(sizeof(B08) == 128, "");
_Static_assert(_Alignof(B08) == 128, "");
_Static_assert(sizeof(struct B08_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B08_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B08_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B08_extra_packed) == 1, "");
_Static_assert(sizeof(struct B08_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B08_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B08_extra_size) == 130, "");
_Static_assert(_Alignof(struct B08_extra_size) == 1, "");
_Static_assert(sizeof(B09) == 128, "");
_Static_assert(_Alignof(B09) == 128, "");
_Static_assert(sizeof(struct B09_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B09_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B09_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B09_extra_packed) == 1, "");
_Static_assert(sizeof(struct B09_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B09_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B09_extra_size) == 130, "");
_Static_assert(_Alignof(struct B09_extra_size) == 1, "");
_Static_assert(sizeof(B10) == 128, "");
_Static_assert(_Alignof(B10) == 128, "");
_Static_assert(sizeof(struct B10_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B10_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B10_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B10_extra_packed) == 1, "");
_Static_assert(sizeof(struct B10_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B10_extra_size) == 130, "");
_Static_assert(_Alignof(struct B10_extra_size) == 1, "");
_Static_assert(sizeof(B11) == 128, "");
_Static_assert(_Alignof(B11) == 128, "");
_Static_assert(sizeof(struct B11_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B11_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B11_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B11_extra_packed) == 1, "");
_Static_assert(sizeof(struct B11_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B11_extra_size) == 130, "");
_Static_assert(_Alignof(struct B11_extra_size) == 1, "");
_Static_assert(sizeof(B12) == 128, "");
_Static_assert(_Alignof(B12) == 128, "");
_Static_assert(sizeof(struct B12_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B12_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B12_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B12_extra_packed) == 1, "");
_Static_assert(sizeof(struct B12_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B12_extra_size) == 130, "");
_Static_assert(_Alignof(struct B12_extra_size) == 1, "");
_Static_assert(sizeof(B13) == 128, "");
_Static_assert(_Alignof(B13) == 128, "");
_Static_assert(sizeof(struct B13_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B13_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B13_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B13_extra_packed) == 1, "");
_Static_assert(sizeof(struct B13_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B13_extra_size) == 130, "");
_Static_assert(_Alignof(struct B13_extra_size) == 1, "");
_Static_assert(sizeof(B14) == 128, "");
_Static_assert(_Alignof(B14) == 128, "");
_Static_assert(sizeof(struct B14_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B14_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B14_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B14_extra_packed) == 1, "");
_Static_assert(sizeof(struct B14_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B14_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B14_extra_size) == 130, "");
_Static_assert(_Alignof(struct B14_extra_size) == 1, "");
_Static_assert(sizeof(B15) == 128, "");
_Static_assert(_Alignof(B15) == 128, "");
_Static_assert(sizeof(struct B15_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B15_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B15_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B15_extra_packed) == 1, "");
_Static_assert(sizeof(struct B15_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B15_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B15_extra_size) == 130, "");
_Static_assert(_Alignof(struct B15_extra_size) == 1, "");
_Static_assert(sizeof(B16) == 128, "");
_Static_assert(_Alignof(B16) == 128, "");
_Static_assert(sizeof(struct B16_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B16_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B16_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B16_extra_packed) == 1, "");
_Static_assert(sizeof(struct B16_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B16_extra_size) == 130, "");
_Static_assert(_Alignof(struct B16_extra_size) == 1, "");
_Static_assert(sizeof(B17) == 128, "");
_Static_assert(_Alignof(B17) == 128, "");
_Static_assert(sizeof(struct B17_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B17_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B17_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B17_extra_packed) == 1, "");
_Static_assert(sizeof(struct B17_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B17_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B17_extra_size) == 130, "");
_Static_assert(_Alignof(struct B17_extra_size) == 1, "");
_Static_assert(sizeof(B18) == 128, "");
_Static_assert(_Alignof(B18) == 128, "");
_Static_assert(sizeof(struct B18_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B18_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B18_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B18_extra_packed) == 1, "");
_Static_assert(sizeof(struct B18_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B18_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B18_extra_size) == 130, "");
_Static_assert(_Alignof(struct B18_extra_size) == 1, "");
_Static_assert(sizeof(B19) == 128, "");
_Static_assert(_Alignof(B19) == 128, "");
_Static_assert(sizeof(struct B19_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B19_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B19_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B19_extra_packed) == 1, "");
_Static_assert(sizeof(struct B19_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B19_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B19_extra_size) == 130, "");
_Static_assert(_Alignof(struct B19_extra_size) == 1, "");
_Static_assert(sizeof(B20) == 128, "");
_Static_assert(_Alignof(B20) == 128, "");
_Static_assert(sizeof(struct B20_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B20_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B20_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B20_extra_packed) == 1, "");
_Static_assert(sizeof(struct B20_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B20_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B20_extra_size) == 130, "");
_Static_assert(_Alignof(struct B20_extra_size) == 1, "");
_Static_assert(sizeof(B21) == 128, "");
_Static_assert(_Alignof(B21) == 128, "");
_Static_assert(sizeof(struct B21_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B21_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B21_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B21_extra_packed) == 1, "");
_Static_assert(sizeof(struct B21_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B21_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B21_extra_size) == 130, "");
_Static_assert(_Alignof(struct B21_extra_size) == 1, "");
_Static_assert(sizeof(B22) == 128, "");
_Static_assert(_Alignof(B22) == 128, "");
_Static_assert(sizeof(struct B22_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B22_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B22_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B22_extra_packed) == 1, "");
_Static_assert(sizeof(struct B22_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B22_extra_size) == 130, "");
_Static_assert(_Alignof(struct B22_extra_size) == 1, "");
_Static_assert(sizeof(B23) == 128, "");
_Static_assert(_Alignof(B23) == 128, "");
_Static_assert(sizeof(struct B23_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B23_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B23_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B23_extra_packed) == 1, "");
_Static_assert(sizeof(struct B23_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B23_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B23_extra_size) == 130, "");
_Static_assert(_Alignof(struct B23_extra_size) == 1, "");
_Static_assert(sizeof(B24) == 128, "");
_Static_assert(_Alignof(B24) == 128, "");
_Static_assert(sizeof(struct B24_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B24_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B24_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B24_extra_packed) == 1, "");
_Static_assert(sizeof(struct B24_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B24_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B24_extra_size) == 130, "");
_Static_assert(_Alignof(struct B24_extra_size) == 1, "");
_Static_assert(sizeof(B25) == 128, "");
_Static_assert(_Alignof(B25) == 128, "");
_Static_assert(sizeof(struct B25_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B25_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B25_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B25_extra_packed) == 1, "");
_Static_assert(sizeof(struct B25_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B25_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B25_extra_size) == 130, "");
_Static_assert(_Alignof(struct B25_extra_size) == 1, "");
_Static_assert(sizeof(B26) == 128, "");
_Static_assert(_Alignof(B26) == 128, "");
_Static_assert(sizeof(struct B26_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B26_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B26_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B26_extra_packed) == 1, "");
_Static_assert(sizeof(struct B26_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B26_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B26_extra_size) == 130, "");
_Static_assert(_Alignof(struct B26_extra_size) == 1, "");
_Static_assert(sizeof(B27) == 128, "");
_Static_assert(_Alignof(B27) == 128, "");
_Static_assert(sizeof(struct B27_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B27_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B27_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B27_extra_packed) == 1, "");
_Static_assert(sizeof(struct B27_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B27_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B27_extra_size) == 130, "");
_Static_assert(_Alignof(struct B27_extra_size) == 1, "");
_Static_assert(sizeof(B28) == 128, "");
_Static_assert(_Alignof(B28) == 128, "");
_Static_assert(sizeof(struct B28_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B28_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B28_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B28_extra_packed) == 1, "");
_Static_assert(sizeof(struct B28_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B28_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B28_extra_size) == 130, "");
_Static_assert(_Alignof(struct B28_extra_size) == 1, "");
_Static_assert(sizeof(B29) == 128, "");
_Static_assert(_Alignof(B29) == 128, "");
_Static_assert(sizeof(struct B29_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B29_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B29_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B29_extra_packed) == 1, "");
_Static_assert(sizeof(struct B29_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B29_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B29_extra_size) == 130, "");
_Static_assert(_Alignof(struct B29_extra_size) == 1, "");
_Static_assert(sizeof(B30) == 128, "");
_Static_assert(_Alignof(B30) == 128, "");
_Static_assert(sizeof(struct B30_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B30_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B30_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B30_extra_packed) == 1, "");
_Static_assert(sizeof(struct B30_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B30_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B30_extra_size) == 130, "");
_Static_assert(_Alignof(struct B30_extra_size) == 1, "");
_Static_assert(sizeof(B31) == 128, "");
_Static_assert(_Alignof(B31) == 128, "");
_Static_assert(sizeof(struct B31_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B31_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B31_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B31_extra_packed) == 1, "");
_Static_assert(sizeof(struct B31_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B31_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B31_extra_size) == 130, "");
_Static_assert(_Alignof(struct B31_extra_size) == 1, "");
_Static_assert(sizeof(B32) == 128, "");
_Static_assert(_Alignof(B32) == 128, "");
_Static_assert(sizeof(struct B32_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B32_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B32_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B32_extra_packed) == 1, "");
_Static_assert(sizeof(struct B32_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B32_extra_size) == 130, "");
_Static_assert(_Alignof(struct B32_extra_size) == 1, "");
_Static_assert(sizeof(B33) == 128, "");
_Static_assert(_Alignof(B33) == 128, "");
_Static_assert(sizeof(struct B33_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B33_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B33_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B33_extra_packed) == 1, "");
_Static_assert(sizeof(struct B33_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B33_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B33_extra_size) == 130, "");
_Static_assert(_Alignof(struct B33_extra_size) == 1, "");
_Static_assert(sizeof(B34) == 128, "");
_Static_assert(_Alignof(B34) == 128, "");
_Static_assert(sizeof(struct B34_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B34_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B34_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B34_extra_packed) == 1, "");
_Static_assert(sizeof(struct B34_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B34_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B34_extra_size) == 130, "");
_Static_assert(_Alignof(struct B34_extra_size) == 1, "");
_Static_assert(sizeof(B35) == 128, "");
_Static_assert(_Alignof(B35) == 128, "");
_Static_assert(sizeof(struct B35_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B35_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B35_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B35_extra_packed) == 1, "");
_Static_assert(sizeof(struct B35_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B35_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B35_extra_size) == 130, "");
_Static_assert(_Alignof(struct B35_extra_size) == 1, "");
_Static_assert(sizeof(B36) == 128, "");
_Static_assert(_Alignof(B36) == 128, "");
_Static_assert(sizeof(struct B36_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B36_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B36_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B36_extra_packed) == 1, "");
_Static_assert(sizeof(struct B36_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B36_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B36_extra_size) == 130, "");
_Static_assert(_Alignof(struct B36_extra_size) == 1, "");
_Static_assert(sizeof(B37) == 128, "");
_Static_assert(_Alignof(B37) == 128, "");
_Static_assert(sizeof(struct B37_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B37_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B37_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B37_extra_packed) == 1, "");
_Static_assert(sizeof(struct B37_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B37_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B37_extra_size) == 130, "");
_Static_assert(_Alignof(struct B37_extra_size) == 1, "");
_Static_assert(sizeof(B38) == 128, "");
_Static_assert(_Alignof(B38) == 128, "");
_Static_assert(sizeof(struct B38_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B38_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B38_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B38_extra_packed) == 1, "");
_Static_assert(sizeof(struct B38_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B38_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B38_extra_size) == 130, "");
_Static_assert(_Alignof(struct B38_extra_size) == 1, "");
_Static_assert(sizeof(B39) == 128, "");
_Static_assert(_Alignof(B39) == 128, "");
_Static_assert(sizeof(struct B39_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B39_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B39_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B39_extra_packed) == 1, "");
_Static_assert(sizeof(struct B39_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B39_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B39_extra_size) == 130, "");
_Static_assert(_Alignof(struct B39_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(THREE)
_Static_assert(sizeof(A00) == 128, "");
_Static_assert(_Alignof(A00) == 128, "");
_Static_assert(sizeof(struct A00_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A00_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A00_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A00_extra_packed) == 1, "");
_Static_assert(sizeof(struct A00_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A00_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A00_extra_size) == 130, "");
_Static_assert(_Alignof(struct A00_extra_size) == 1, "");
_Static_assert(sizeof(A01) == 8, "");
_Static_assert(_Alignof(A01) == 1, "");
_Static_assert(sizeof(struct A01_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A01_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A01_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A01_extra_packed) == 1, "");
_Static_assert(sizeof(struct A01_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A01_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A01_extra_size) == 10, "");
_Static_assert(_Alignof(struct A01_extra_size) == 1, "");
_Static_assert(sizeof(A02) == 8, "");
_Static_assert(_Alignof(A02) == 2, "");
_Static_assert(sizeof(struct A02_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A02_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A02_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A02_extra_packed) == 1, "");
_Static_assert(sizeof(struct A02_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A02_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A02_extra_size) == 10, "");
_Static_assert(_Alignof(struct A02_extra_size) == 1, "");
_Static_assert(sizeof(A03) == 128, "");
_Static_assert(_Alignof(A03) == 128, "");
_Static_assert(sizeof(struct A03_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A03_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A03_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A03_extra_packed) == 1, "");
_Static_assert(sizeof(struct A03_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A03_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A03_extra_size) == 130, "");
_Static_assert(_Alignof(struct A03_extra_size) == 1, "");
_Static_assert(sizeof(A04) == 8, "");
_Static_assert(_Alignof(A04) == 4, "");
_Static_assert(sizeof(struct A04_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A04_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A04_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A04_extra_packed) == 1, "");
_Static_assert(sizeof(struct A04_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A04_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A04_extra_size) == 10, "");
_Static_assert(_Alignof(struct A04_extra_size) == 1, "");
_Static_assert(sizeof(A05) == 128, "");
_Static_assert(_Alignof(A05) == 128, "");
_Static_assert(sizeof(struct A05_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A05_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A05_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A05_extra_packed) == 1, "");
_Static_assert(sizeof(struct A05_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A05_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A05_extra_size) == 130, "");
_Static_assert(_Alignof(struct A05_extra_size) == 1, "");
_Static_assert(sizeof(A06) == 128, "");
_Static_assert(_Alignof(A06) == 128, "");
_Static_assert(sizeof(struct A06_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A06_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A06_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A06_extra_packed) == 1, "");
_Static_assert(sizeof(struct A06_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A06_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A06_extra_size) == 130, "");
_Static_assert(_Alignof(struct A06_extra_size) == 1, "");
_Static_assert(sizeof(A07) == 128, "");
_Static_assert(_Alignof(A07) == 128, "");
_Static_assert(sizeof(struct A07_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A07_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A07_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A07_extra_packed) == 1, "");
_Static_assert(sizeof(struct A07_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A07_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A07_extra_size) == 130, "");
_Static_assert(_Alignof(struct A07_extra_size) == 1, "");
_Static_assert(sizeof(A08) == 8, "");
_Static_assert(_Alignof(A08) == 8, "");
_Static_assert(sizeof(struct A08_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A08_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A08_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A08_extra_packed) == 1, "");
_Static_assert(sizeof(struct A08_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A08_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A08_extra_size) == 10, "");
_Static_assert(_Alignof(struct A08_extra_size) == 1, "");
_Static_assert(sizeof(A09) == 128, "");
_Static_assert(_Alignof(A09) == 128, "");
_Static_assert(sizeof(struct A09_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A09_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A09_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A09_extra_packed) == 1, "");
_Static_assert(sizeof(struct A09_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A09_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A09_extra_size) == 130, "");
_Static_assert(_Alignof(struct A09_extra_size) == 1, "");
_Static_assert(sizeof(A10) == 128, "");
_Static_assert(_Alignof(A10) == 128, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A10_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 130, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 128, "");
_Static_assert(_Alignof(A11) == 128, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A11_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 130, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
_Static_assert(sizeof(A12) == 128, "");
_Static_assert(_Alignof(A12) == 128, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A12_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 130, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
_Static_assert(sizeof(A13) == 128, "");
_Static_assert(_Alignof(A13) == 128, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A13_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 130, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
_Static_assert(sizeof(A14) == 128, "");
_Static_assert(_Alignof(A14) == 128, "");
_Static_assert(sizeof(struct A14_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A14_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A14_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A14_extra_packed) == 1, "");
_Static_assert(sizeof(struct A14_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A14_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A14_extra_size) == 130, "");
_Static_assert(_Alignof(struct A14_extra_size) == 1, "");
_Static_assert(sizeof(A15) == 128, "");
_Static_assert(_Alignof(A15) == 128, "");
_Static_assert(sizeof(struct A15_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A15_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A15_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A15_extra_packed) == 1, "");
_Static_assert(sizeof(struct A15_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A15_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A15_extra_size) == 130, "");
_Static_assert(_Alignof(struct A15_extra_size) == 1, "");
_Static_assert(sizeof(A16) == 16, "");
_Static_assert(_Alignof(A16) == 16, "");
_Static_assert(sizeof(struct A16_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A16_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A16_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A16_extra_packed) == 1, "");
_Static_assert(sizeof(struct A16_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A16_extra_size) == 18, "");
_Static_assert(_Alignof(struct A16_extra_size) == 1, "");
_Static_assert(sizeof(A17) == 128, "");
_Static_assert(_Alignof(A17) == 128, "");
_Static_assert(sizeof(struct A17_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A17_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A17_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A17_extra_packed) == 1, "");
_Static_assert(sizeof(struct A17_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A17_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A17_extra_size) == 130, "");
_Static_assert(_Alignof(struct A17_extra_size) == 1, "");
_Static_assert(sizeof(A18) == 128, "");
_Static_assert(_Alignof(A18) == 128, "");
_Static_assert(sizeof(struct A18_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A18_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A18_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A18_extra_packed) == 1, "");
_Static_assert(sizeof(struct A18_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A18_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A18_extra_size) == 130, "");
_Static_assert(_Alignof(struct A18_extra_size) == 1, "");
_Static_assert(sizeof(A19) == 128, "");
_Static_assert(_Alignof(A19) == 128, "");
_Static_assert(sizeof(struct A19_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A19_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A19_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A19_extra_packed) == 1, "");
_Static_assert(sizeof(struct A19_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A19_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A19_extra_size) == 130, "");
_Static_assert(_Alignof(struct A19_extra_size) == 1, "");
_Static_assert(sizeof(A20) == 128, "");
_Static_assert(_Alignof(A20) == 128, "");
_Static_assert(sizeof(struct A20_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A20_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A20_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A20_extra_packed) == 1, "");
_Static_assert(sizeof(struct A20_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A20_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A20_extra_size) == 130, "");
_Static_assert(_Alignof(struct A20_extra_size) == 1, "");
_Static_assert(sizeof(A21) == 128, "");
_Static_assert(_Alignof(A21) == 128, "");
_Static_assert(sizeof(struct A21_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A21_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A21_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A21_extra_packed) == 1, "");
_Static_assert(sizeof(struct A21_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A21_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A21_extra_size) == 130, "");
_Static_assert(_Alignof(struct A21_extra_size) == 1, "");
_Static_assert(sizeof(A22) == 128, "");
_Static_assert(_Alignof(A22) == 128, "");
_Static_assert(sizeof(struct A22_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A22_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A22_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A22_extra_packed) == 1, "");
_Static_assert(sizeof(struct A22_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A22_extra_size) == 130, "");
_Static_assert(_Alignof(struct A22_extra_size) == 1, "");
_Static_assert(sizeof(A23) == 128, "");
_Static_assert(_Alignof(A23) == 128, "");
_Static_assert(sizeof(struct A23_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A23_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A23_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A23_extra_packed) == 1, "");
_Static_assert(sizeof(struct A23_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A23_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A23_extra_size) == 130, "");
_Static_assert(_Alignof(struct A23_extra_size) == 1, "");
_Static_assert(sizeof(A24) == 128, "");
_Static_assert(_Alignof(A24) == 128, "");
_Static_assert(sizeof(struct A24_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A24_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A24_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A24_extra_packed) == 1, "");
_Static_assert(sizeof(struct A24_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A24_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A24_extra_size) == 130, "");
_Static_assert(_Alignof(struct A24_extra_size) == 1, "");
_Static_assert(sizeof(A25) == 128, "");
_Static_assert(_Alignof(A25) == 128, "");
_Static_assert(sizeof(struct A25_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A25_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A25_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A25_extra_packed) == 1, "");
_Static_assert(sizeof(struct A25_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A25_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A25_extra_size) == 130, "");
_Static_assert(_Alignof(struct A25_extra_size) == 1, "");
_Static_assert(sizeof(A26) == 128, "");
_Static_assert(_Alignof(A26) == 128, "");
_Static_assert(sizeof(struct A26_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A26_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A26_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A26_extra_packed) == 1, "");
_Static_assert(sizeof(struct A26_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A26_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A26_extra_size) == 130, "");
_Static_assert(_Alignof(struct A26_extra_size) == 1, "");
_Static_assert(sizeof(A27) == 128, "");
_Static_assert(_Alignof(A27) == 128, "");
_Static_assert(sizeof(struct A27_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A27_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A27_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A27_extra_packed) == 1, "");
_Static_assert(sizeof(struct A27_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A27_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A27_extra_size) == 130, "");
_Static_assert(_Alignof(struct A27_extra_size) == 1, "");
_Static_assert(sizeof(A28) == 128, "");
_Static_assert(_Alignof(A28) == 128, "");
_Static_assert(sizeof(struct A28_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A28_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A28_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A28_extra_packed) == 1, "");
_Static_assert(sizeof(struct A28_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A28_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A28_extra_size) == 130, "");
_Static_assert(_Alignof(struct A28_extra_size) == 1, "");
_Static_assert(sizeof(A29) == 128, "");
_Static_assert(_Alignof(A29) == 128, "");
_Static_assert(sizeof(struct A29_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A29_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A29_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A29_extra_packed) == 1, "");
_Static_assert(sizeof(struct A29_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A29_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A29_extra_size) == 130, "");
_Static_assert(_Alignof(struct A29_extra_size) == 1, "");
_Static_assert(sizeof(A30) == 128, "");
_Static_assert(_Alignof(A30) == 128, "");
_Static_assert(sizeof(struct A30_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A30_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A30_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A30_extra_packed) == 1, "");
_Static_assert(sizeof(struct A30_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A30_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A30_extra_size) == 130, "");
_Static_assert(_Alignof(struct A30_extra_size) == 1, "");
_Static_assert(sizeof(A31) == 128, "");
_Static_assert(_Alignof(A31) == 128, "");
_Static_assert(sizeof(struct A31_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A31_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A31_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A31_extra_packed) == 1, "");
_Static_assert(sizeof(struct A31_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A31_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A31_extra_size) == 130, "");
_Static_assert(_Alignof(struct A31_extra_size) == 1, "");
_Static_assert(sizeof(A32) == 128, "");
_Static_assert(_Alignof(A32) == 128, "");
_Static_assert(sizeof(struct A32_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A32_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A32_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A32_extra_packed) == 1, "");
_Static_assert(sizeof(struct A32_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A32_extra_size) == 130, "");
_Static_assert(_Alignof(struct A32_extra_size) == 1, "");
_Static_assert(sizeof(A33) == 128, "");
_Static_assert(_Alignof(A33) == 128, "");
_Static_assert(sizeof(struct A33_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A33_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A33_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A33_extra_packed) == 1, "");
_Static_assert(sizeof(struct A33_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A33_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A33_extra_size) == 130, "");
_Static_assert(_Alignof(struct A33_extra_size) == 1, "");
_Static_assert(sizeof(A34) == 128, "");
_Static_assert(_Alignof(A34) == 128, "");
_Static_assert(sizeof(struct A34_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A34_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A34_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A34_extra_packed) == 1, "");
_Static_assert(sizeof(struct A34_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A34_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A34_extra_size) == 130, "");
_Static_assert(_Alignof(struct A34_extra_size) == 1, "");
_Static_assert(sizeof(A35) == 128, "");
_Static_assert(_Alignof(A35) == 128, "");
_Static_assert(sizeof(struct A35_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A35_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A35_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A35_extra_packed) == 1, "");
_Static_assert(sizeof(struct A35_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A35_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A35_extra_size) == 130, "");
_Static_assert(_Alignof(struct A35_extra_size) == 1, "");
_Static_assert(sizeof(A36) == 128, "");
_Static_assert(_Alignof(A36) == 128, "");
_Static_assert(sizeof(struct A36_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A36_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A36_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A36_extra_packed) == 1, "");
_Static_assert(sizeof(struct A36_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A36_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A36_extra_size) == 130, "");
_Static_assert(_Alignof(struct A36_extra_size) == 1, "");
_Static_assert(sizeof(A37) == 128, "");
_Static_assert(_Alignof(A37) == 128, "");
_Static_assert(sizeof(struct A37_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A37_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A37_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A37_extra_packed) == 1, "");
_Static_assert(sizeof(struct A37_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A37_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A37_extra_size) == 130, "");
_Static_assert(_Alignof(struct A37_extra_size) == 1, "");
_Static_assert(sizeof(A38) == 128, "");
_Static_assert(_Alignof(A38) == 128, "");
_Static_assert(sizeof(struct A38_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A38_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A38_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A38_extra_packed) == 1, "");
_Static_assert(sizeof(struct A38_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A38_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A38_extra_size) == 130, "");
_Static_assert(_Alignof(struct A38_extra_size) == 1, "");
_Static_assert(sizeof(A39) == 128, "");
_Static_assert(_Alignof(A39) == 128, "");
_Static_assert(sizeof(struct A39_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A39_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A39_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A39_extra_packed) == 1, "");
_Static_assert(sizeof(struct A39_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A39_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A39_extra_size) == 130, "");
_Static_assert(_Alignof(struct A39_extra_size) == 1, "");
_Static_assert(sizeof(B00) == 128, "");
_Static_assert(_Alignof(B00) == 128, "");
_Static_assert(sizeof(struct B00_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B00_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B00_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B00_extra_packed) == 1, "");
_Static_assert(sizeof(struct B00_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B00_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B00_extra_size) == 130, "");
_Static_assert(_Alignof(struct B00_extra_size) == 1, "");
_Static_assert(sizeof(B01) == 8, "");
_Static_assert(_Alignof(B01) == 1, "");
_Static_assert(sizeof(struct B01_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B01_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B01_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B01_extra_packed) == 1, "");
_Static_assert(sizeof(struct B01_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B01_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B01_extra_size) == 10, "");
_Static_assert(_Alignof(struct B01_extra_size) == 1, "");
_Static_assert(sizeof(B02) == 8, "");
_Static_assert(_Alignof(B02) == 2, "");
_Static_assert(sizeof(struct B02_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B02_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B02_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B02_extra_packed) == 1, "");
_Static_assert(sizeof(struct B02_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B02_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B02_extra_size) == 10, "");
_Static_assert(_Alignof(struct B02_extra_size) == 1, "");
_Static_assert(sizeof(B03) == 128, "");
_Static_assert(_Alignof(B03) == 128, "");
_Static_assert(sizeof(struct B03_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B03_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B03_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B03_extra_packed) == 1, "");
_Static_assert(sizeof(struct B03_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B03_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B03_extra_size) == 130, "");
_Static_assert(_Alignof(struct B03_extra_size) == 1, "");
_Static_assert(sizeof(B04) == 8, "");
_Static_assert(_Alignof(B04) == 4, "");
_Static_assert(sizeof(struct B04_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B04_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B04_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B04_extra_packed) == 1, "");
_Static_assert(sizeof(struct B04_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B04_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B04_extra_size) == 10, "");
_Static_assert(_Alignof(struct B04_extra_size) == 1, "");
_Static_assert(sizeof(B05) == 128, "");
_Static_assert(_Alignof(B05) == 128, "");
_Static_assert(sizeof(struct B05_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B05_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B05_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B05_extra_packed) == 1, "");
_Static_assert(sizeof(struct B05_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B05_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B05_extra_size) == 130, "");
_Static_assert(_Alignof(struct B05_extra_size) == 1, "");
_Static_assert(sizeof(B06) == 128, "");
_Static_assert(_Alignof(B06) == 128, "");
_Static_assert(sizeof(struct B06_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B06_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B06_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B06_extra_packed) == 1, "");
_Static_assert(sizeof(struct B06_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B06_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B06_extra_size) == 130, "");
_Static_assert(_Alignof(struct B06_extra_size) == 1, "");
_Static_assert(sizeof(B07) == 128, "");
_Static_assert(_Alignof(B07) == 128, "");
_Static_assert(sizeof(struct B07_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B07_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B07_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B07_extra_packed) == 1, "");
_Static_assert(sizeof(struct B07_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B07_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B07_extra_size) == 130, "");
_Static_assert(_Alignof(struct B07_extra_size) == 1, "");
_Static_assert(sizeof(B08) == 8, "");
_Static_assert(_Alignof(B08) == 8, "");
_Static_assert(sizeof(struct B08_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B08_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B08_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B08_extra_packed) == 1, "");
_Static_assert(sizeof(struct B08_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B08_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B08_extra_size) == 10, "");
_Static_assert(_Alignof(struct B08_extra_size) == 1, "");
_Static_assert(sizeof(B09) == 128, "");
_Static_assert(_Alignof(B09) == 128, "");
_Static_assert(sizeof(struct B09_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B09_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B09_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B09_extra_packed) == 1, "");
_Static_assert(sizeof(struct B09_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B09_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B09_extra_size) == 130, "");
_Static_assert(_Alignof(struct B09_extra_size) == 1, "");
_Static_assert(sizeof(B10) == 128, "");
_Static_assert(_Alignof(B10) == 128, "");
_Static_assert(sizeof(struct B10_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B10_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B10_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B10_extra_packed) == 1, "");
_Static_assert(sizeof(struct B10_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B10_extra_size) == 130, "");
_Static_assert(_Alignof(struct B10_extra_size) == 1, "");
_Static_assert(sizeof(B11) == 128, "");
_Static_assert(_Alignof(B11) == 128, "");
_Static_assert(sizeof(struct B11_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B11_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B11_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B11_extra_packed) == 1, "");
_Static_assert(sizeof(struct B11_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B11_extra_size) == 130, "");
_Static_assert(_Alignof(struct B11_extra_size) == 1, "");
_Static_assert(sizeof(B12) == 128, "");
_Static_assert(_Alignof(B12) == 128, "");
_Static_assert(sizeof(struct B12_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B12_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B12_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B12_extra_packed) == 1, "");
_Static_assert(sizeof(struct B12_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B12_extra_size) == 130, "");
_Static_assert(_Alignof(struct B12_extra_size) == 1, "");
_Static_assert(sizeof(B13) == 128, "");
_Static_assert(_Alignof(B13) == 128, "");
_Static_assert(sizeof(struct B13_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B13_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B13_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B13_extra_packed) == 1, "");
_Static_assert(sizeof(struct B13_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B13_extra_size) == 130, "");
_Static_assert(_Alignof(struct B13_extra_size) == 1, "");
_Static_assert(sizeof(B14) == 128, "");
_Static_assert(_Alignof(B14) == 128, "");
_Static_assert(sizeof(struct B14_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B14_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B14_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B14_extra_packed) == 1, "");
_Static_assert(sizeof(struct B14_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B14_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B14_extra_size) == 130, "");
_Static_assert(_Alignof(struct B14_extra_size) == 1, "");
_Static_assert(sizeof(B15) == 128, "");
_Static_assert(_Alignof(B15) == 128, "");
_Static_assert(sizeof(struct B15_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B15_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B15_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B15_extra_packed) == 1, "");
_Static_assert(sizeof(struct B15_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B15_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B15_extra_size) == 130, "");
_Static_assert(_Alignof(struct B15_extra_size) == 1, "");
_Static_assert(sizeof(B16) == 16, "");
_Static_assert(_Alignof(B16) == 16, "");
_Static_assert(sizeof(struct B16_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B16_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B16_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B16_extra_packed) == 1, "");
_Static_assert(sizeof(struct B16_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B16_extra_size) == 18, "");
_Static_assert(_Alignof(struct B16_extra_size) == 1, "");
_Static_assert(sizeof(B17) == 128, "");
_Static_assert(_Alignof(B17) == 128, "");
_Static_assert(sizeof(struct B17_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B17_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B17_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B17_extra_packed) == 1, "");
_Static_assert(sizeof(struct B17_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B17_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B17_extra_size) == 130, "");
_Static_assert(_Alignof(struct B17_extra_size) == 1, "");
_Static_assert(sizeof(B18) == 128, "");
_Static_assert(_Alignof(B18) == 128, "");
_Static_assert(sizeof(struct B18_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B18_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B18_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B18_extra_packed) == 1, "");
_Static_assert(sizeof(struct B18_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B18_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B18_extra_size) == 130, "");
_Static_assert(_Alignof(struct B18_extra_size) == 1, "");
_Static_assert(sizeof(B19) == 128, "");
_Static_assert(_Alignof(B19) == 128, "");
_Static_assert(sizeof(struct B19_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B19_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B19_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B19_extra_packed) == 1, "");
_Static_assert(sizeof(struct B19_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B19_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B19_extra_size) == 130, "");
_Static_assert(_Alignof(struct B19_extra_size) == 1, "");
_Static_assert(sizeof(B20) == 128, "");
_Static_assert(_Alignof(B20) == 128, "");
_Static_assert(sizeof(struct B20_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B20_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B20_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B20_extra_packed) == 1, "");
_Static_assert(sizeof(struct B20_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B20_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B20_extra_size) == 130, "");
_Static_assert(_Alignof(struct B20_extra_size) == 1, "");
_Static_assert(sizeof(B21) == 128, "");
_Static_assert(_Alignof(B21) == 128, "");
_Static_assert(sizeof(struct B21_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B21_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B21_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B21_extra_packed) == 1, "");
_Static_assert(sizeof(struct B21_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B21_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B21_extra_size) == 130, "");
_Static_assert(_Alignof(struct B21_extra_size) == 1, "");
_Static_assert(sizeof(B22) == 128, "");
_Static_assert(_Alignof(B22) == 128, "");
_Static_assert(sizeof(struct B22_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B22_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B22_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B22_extra_packed) == 1, "");
_Static_assert(sizeof(struct B22_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B22_extra_size) == 130, "");
_Static_assert(_Alignof(struct B22_extra_size) == 1, "");
_Static_assert(sizeof(B23) == 128, "");
_Static_assert(_Alignof(B23) == 128, "");
_Static_assert(sizeof(struct B23_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B23_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B23_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B23_extra_packed) == 1, "");
_Static_assert(sizeof(struct B23_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B23_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B23_extra_size) == 130, "");
_Static_assert(_Alignof(struct B23_extra_size) == 1, "");
_Static_assert(sizeof(B24) == 128, "");
_Static_assert(_Alignof(B24) == 128, "");
_Static_assert(sizeof(struct B24_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B24_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B24_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B24_extra_packed) == 1, "");
_Static_assert(sizeof(struct B24_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B24_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B24_extra_size) == 130, "");
_Static_assert(_Alignof(struct B24_extra_size) == 1, "");
_Static_assert(sizeof(B25) == 128, "");
_Static_assert(_Alignof(B25) == 128, "");
_Static_assert(sizeof(struct B25_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B25_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B25_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B25_extra_packed) == 1, "");
_Static_assert(sizeof(struct B25_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B25_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B25_extra_size) == 130, "");
_Static_assert(_Alignof(struct B25_extra_size) == 1, "");
_Static_assert(sizeof(B26) == 128, "");
_Static_assert(_Alignof(B26) == 128, "");
_Static_assert(sizeof(struct B26_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B26_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B26_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B26_extra_packed) == 1, "");
_Static_assert(sizeof(struct B26_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B26_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B26_extra_size) == 130, "");
_Static_assert(_Alignof(struct B26_extra_size) == 1, "");
_Static_assert(sizeof(B27) == 128, "");
_Static_assert(_Alignof(B27) == 128, "");
_Static_assert(sizeof(struct B27_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B27_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B27_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B27_extra_packed) == 1, "");
_Static_assert(sizeof(struct B27_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B27_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B27_extra_size) == 130, "");
_Static_assert(_Alignof(struct B27_extra_size) == 1, "");
_Static_assert(sizeof(B28) == 128, "");
_Static_assert(_Alignof(B28) == 128, "");
_Static_assert(sizeof(struct B28_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B28_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B28_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B28_extra_packed) == 1, "");
_Static_assert(sizeof(struct B28_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B28_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B28_extra_size) == 130, "");
_Static_assert(_Alignof(struct B28_extra_size) == 1, "");
_Static_assert(sizeof(B29) == 128, "");
_Static_assert(_Alignof(B29) == 128, "");
_Static_assert(sizeof(struct B29_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B29_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B29_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B29_extra_packed) == 1, "");
_Static_assert(sizeof(struct B29_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B29_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B29_extra_size) == 130, "");
_Static_assert(_Alignof(struct B29_extra_size) == 1, "");
_Static_assert(sizeof(B30) == 128, "");
_Static_assert(_Alignof(B30) == 128, "");
_Static_assert(sizeof(struct B30_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B30_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B30_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B30_extra_packed) == 1, "");
_Static_assert(sizeof(struct B30_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B30_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B30_extra_size) == 130, "");
_Static_assert(_Alignof(struct B30_extra_size) == 1, "");
_Static_assert(sizeof(B31) == 128, "");
_Static_assert(_Alignof(B31) == 128, "");
_Static_assert(sizeof(struct B31_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B31_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B31_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B31_extra_packed) == 1, "");
_Static_assert(sizeof(struct B31_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B31_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B31_extra_size) == 130, "");
_Static_assert(_Alignof(struct B31_extra_size) == 1, "");
_Static_assert(sizeof(B32) == 128, "");
_Static_assert(_Alignof(B32) == 128, "");
_Static_assert(sizeof(struct B32_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B32_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B32_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B32_extra_packed) == 1, "");
_Static_assert(sizeof(struct B32_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B32_extra_size) == 130, "");
_Static_assert(_Alignof(struct B32_extra_size) == 1, "");
_Static_assert(sizeof(B33) == 128, "");
_Static_assert(_Alignof(B33) == 128, "");
_Static_assert(sizeof(struct B33_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B33_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B33_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B33_extra_packed) == 1, "");
_Static_assert(sizeof(struct B33_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B33_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B33_extra_size) == 130, "");
_Static_assert(_Alignof(struct B33_extra_size) == 1, "");
_Static_assert(sizeof(B34) == 128, "");
_Static_assert(_Alignof(B34) == 128, "");
_Static_assert(sizeof(struct B34_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B34_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B34_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B34_extra_packed) == 1, "");
_Static_assert(sizeof(struct B34_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B34_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B34_extra_size) == 130, "");
_Static_assert(_Alignof(struct B34_extra_size) == 1, "");
_Static_assert(sizeof(B35) == 128, "");
_Static_assert(_Alignof(B35) == 128, "");
_Static_assert(sizeof(struct B35_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B35_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B35_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B35_extra_packed) == 1, "");
_Static_assert(sizeof(struct B35_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B35_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B35_extra_size) == 130, "");
_Static_assert(_Alignof(struct B35_extra_size) == 1, "");
_Static_assert(sizeof(B36) == 128, "");
_Static_assert(_Alignof(B36) == 128, "");
_Static_assert(sizeof(struct B36_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B36_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B36_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B36_extra_packed) == 1, "");
_Static_assert(sizeof(struct B36_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B36_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B36_extra_size) == 130, "");
_Static_assert(_Alignof(struct B36_extra_size) == 1, "");
_Static_assert(sizeof(B37) == 128, "");
_Static_assert(_Alignof(B37) == 128, "");
_Static_assert(sizeof(struct B37_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B37_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B37_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B37_extra_packed) == 1, "");
_Static_assert(sizeof(struct B37_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B37_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B37_extra_size) == 130, "");
_Static_assert(_Alignof(struct B37_extra_size) == 1, "");
_Static_assert(sizeof(B38) == 128, "");
_Static_assert(_Alignof(B38) == 128, "");
_Static_assert(sizeof(struct B38_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B38_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B38_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B38_extra_packed) == 1, "");
_Static_assert(sizeof(struct B38_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B38_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B38_extra_size) == 130, "");
_Static_assert(_Alignof(struct B38_extra_size) == 1, "");
_Static_assert(sizeof(B39) == 128, "");
_Static_assert(_Alignof(B39) == 128, "");
_Static_assert(sizeof(struct B39_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B39_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B39_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B39_extra_packed) == 1, "");
_Static_assert(sizeof(struct B39_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B39_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B39_extra_size) == 130, "");
_Static_assert(_Alignof(struct B39_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A00) == 128, "");
_Static_assert(_Alignof(A00) == 128, "");
_Static_assert(sizeof(struct A00_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A00_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A00_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A00_extra_packed) == 1, "");
_Static_assert(sizeof(struct A00_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A00_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A00_extra_size) == 130, "");
_Static_assert(_Alignof(struct A00_extra_size) == 1, "");
_Static_assert(sizeof(A01) == 8, "");
_Static_assert(_Alignof(A01) == 1, "");
_Static_assert(sizeof(struct A01_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A01_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A01_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A01_extra_packed) == 1, "");
_Static_assert(sizeof(struct A01_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A01_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A01_extra_size) == 10, "");
_Static_assert(_Alignof(struct A01_extra_size) == 1, "");
_Static_assert(sizeof(A02) == 8, "");
_Static_assert(_Alignof(A02) == 2, "");
_Static_assert(sizeof(struct A02_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A02_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A02_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A02_extra_packed) == 1, "");
_Static_assert(sizeof(struct A02_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A02_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A02_extra_size) == 10, "");
_Static_assert(_Alignof(struct A02_extra_size) == 1, "");
_Static_assert(sizeof(A03) == 128, "");
_Static_assert(_Alignof(A03) == 128, "");
_Static_assert(sizeof(struct A03_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A03_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A03_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A03_extra_packed) == 1, "");
_Static_assert(sizeof(struct A03_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A03_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A03_extra_size) == 130, "");
_Static_assert(_Alignof(struct A03_extra_size) == 1, "");
_Static_assert(sizeof(A04) == 8, "");
_Static_assert(_Alignof(A04) == 4, "");
_Static_assert(sizeof(struct A04_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A04_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A04_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A04_extra_packed) == 1, "");
_Static_assert(sizeof(struct A04_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A04_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A04_extra_size) == 10, "");
_Static_assert(_Alignof(struct A04_extra_size) == 1, "");
_Static_assert(sizeof(A05) == 128, "");
_Static_assert(_Alignof(A05) == 128, "");
_Static_assert(sizeof(struct A05_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A05_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A05_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A05_extra_packed) == 1, "");
_Static_assert(sizeof(struct A05_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A05_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A05_extra_size) == 130, "");
_Static_assert(_Alignof(struct A05_extra_size) == 1, "");
_Static_assert(sizeof(A06) == 128, "");
_Static_assert(_Alignof(A06) == 128, "");
_Static_assert(sizeof(struct A06_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A06_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A06_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A06_extra_packed) == 1, "");
_Static_assert(sizeof(struct A06_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A06_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A06_extra_size) == 130, "");
_Static_assert(_Alignof(struct A06_extra_size) == 1, "");
_Static_assert(sizeof(A07) == 128, "");
_Static_assert(_Alignof(A07) == 128, "");
_Static_assert(sizeof(struct A07_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A07_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A07_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A07_extra_packed) == 1, "");
_Static_assert(sizeof(struct A07_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A07_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A07_extra_size) == 130, "");
_Static_assert(_Alignof(struct A07_extra_size) == 1, "");
_Static_assert(sizeof(A08) == 8, "");
_Static_assert(_Alignof(A08) == 8, "");
_Static_assert(sizeof(struct A08_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A08_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A08_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A08_extra_packed) == 1, "");
_Static_assert(sizeof(struct A08_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A08_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A08_extra_size) == 10, "");
_Static_assert(_Alignof(struct A08_extra_size) == 1, "");
_Static_assert(sizeof(A09) == 128, "");
_Static_assert(_Alignof(A09) == 128, "");
_Static_assert(sizeof(struct A09_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A09_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A09_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A09_extra_packed) == 1, "");
_Static_assert(sizeof(struct A09_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A09_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A09_extra_size) == 130, "");
_Static_assert(_Alignof(struct A09_extra_size) == 1, "");
_Static_assert(sizeof(A10) == 128, "");
_Static_assert(_Alignof(A10) == 128, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A10_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 130, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 128, "");
_Static_assert(_Alignof(A11) == 128, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A11_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 130, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
_Static_assert(sizeof(A12) == 128, "");
_Static_assert(_Alignof(A12) == 128, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A12_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 130, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
_Static_assert(sizeof(A13) == 128, "");
_Static_assert(_Alignof(A13) == 128, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A13_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 130, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
_Static_assert(sizeof(A14) == 128, "");
_Static_assert(_Alignof(A14) == 128, "");
_Static_assert(sizeof(struct A14_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A14_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A14_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A14_extra_packed) == 1, "");
_Static_assert(sizeof(struct A14_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A14_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A14_extra_size) == 130, "");
_Static_assert(_Alignof(struct A14_extra_size) == 1, "");
_Static_assert(sizeof(A15) == 128, "");
_Static_assert(_Alignof(A15) == 128, "");
_Static_assert(sizeof(struct A15_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A15_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A15_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A15_extra_packed) == 1, "");
_Static_assert(sizeof(struct A15_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A15_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A15_extra_size) == 130, "");
_Static_assert(_Alignof(struct A15_extra_size) == 1, "");
_Static_assert(sizeof(A16) == 16, "");
_Static_assert(_Alignof(A16) == 16, "");
_Static_assert(sizeof(struct A16_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A16_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A16_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A16_extra_packed) == 1, "");
_Static_assert(sizeof(struct A16_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A16_extra_size) == 18, "");
_Static_assert(_Alignof(struct A16_extra_size) == 1, "");
_Static_assert(sizeof(A17) == 128, "");
_Static_assert(_Alignof(A17) == 128, "");
_Static_assert(sizeof(struct A17_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A17_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A17_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A17_extra_packed) == 1, "");
_Static_assert(sizeof(struct A17_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A17_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A17_extra_size) == 130, "");
_Static_assert(_Alignof(struct A17_extra_size) == 1, "");
_Static_assert(sizeof(A18) == 128, "");
_Static_assert(_Alignof(A18) == 128, "");
_Static_assert(sizeof(struct A18_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A18_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A18_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A18_extra_packed) == 1, "");
_Static_assert(sizeof(struct A18_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A18_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A18_extra_size) == 130, "");
_Static_assert(_Alignof(struct A18_extra_size) == 1, "");
_Static_assert(sizeof(A19) == 128, "");
_Static_assert(_Alignof(A19) == 128, "");
_Static_assert(sizeof(struct A19_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A19_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A19_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A19_extra_packed) == 1, "");
_Static_assert(sizeof(struct A19_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A19_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A19_extra_size) == 130, "");
_Static_assert(_Alignof(struct A19_extra_size) == 1, "");
_Static_assert(sizeof(A20) == 128, "");
_Static_assert(_Alignof(A20) == 128, "");
_Static_assert(sizeof(struct A20_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A20_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A20_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A20_extra_packed) == 1, "");
_Static_assert(sizeof(struct A20_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A20_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A20_extra_size) == 130, "");
_Static_assert(_Alignof(struct A20_extra_size) == 1, "");
_Static_assert(sizeof(A21) == 128, "");
_Static_assert(_Alignof(A21) == 128, "");
_Static_assert(sizeof(struct A21_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A21_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A21_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A21_extra_packed) == 1, "");
_Static_assert(sizeof(struct A21_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A21_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A21_extra_size) == 130, "");
_Static_assert(_Alignof(struct A21_extra_size) == 1, "");
_Static_assert(sizeof(A22) == 128, "");
_Static_assert(_Alignof(A22) == 128, "");
_Static_assert(sizeof(struct A22_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A22_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A22_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A22_extra_packed) == 1, "");
_Static_assert(sizeof(struct A22_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A22_extra_size) == 130, "");
_Static_assert(_Alignof(struct A22_extra_size) == 1, "");
_Static_assert(sizeof(A23) == 128, "");
_Static_assert(_Alignof(A23) == 128, "");
_Static_assert(sizeof(struct A23_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A23_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A23_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A23_extra_packed) == 1, "");
_Static_assert(sizeof(struct A23_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A23_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A23_extra_size) == 130, "");
_Static_assert(_Alignof(struct A23_extra_size) == 1, "");
_Static_assert(sizeof(A24) == 128, "");
_Static_assert(_Alignof(A24) == 128, "");
_Static_assert(sizeof(struct A24_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A24_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A24_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A24_extra_packed) == 1, "");
_Static_assert(sizeof(struct A24_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A24_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A24_extra_size) == 130, "");
_Static_assert(_Alignof(struct A24_extra_size) == 1, "");
_Static_assert(sizeof(A25) == 128, "");
_Static_assert(_Alignof(A25) == 128, "");
_Static_assert(sizeof(struct A25_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A25_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A25_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A25_extra_packed) == 1, "");
_Static_assert(sizeof(struct A25_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A25_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A25_extra_size) == 130, "");
_Static_assert(_Alignof(struct A25_extra_size) == 1, "");
_Static_assert(sizeof(A26) == 128, "");
_Static_assert(_Alignof(A26) == 128, "");
_Static_assert(sizeof(struct A26_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A26_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A26_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A26_extra_packed) == 1, "");
_Static_assert(sizeof(struct A26_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A26_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A26_extra_size) == 130, "");
_Static_assert(_Alignof(struct A26_extra_size) == 1, "");
_Static_assert(sizeof(A27) == 128, "");
_Static_assert(_Alignof(A27) == 128, "");
_Static_assert(sizeof(struct A27_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A27_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A27_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A27_extra_packed) == 1, "");
_Static_assert(sizeof(struct A27_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A27_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A27_extra_size) == 130, "");
_Static_assert(_Alignof(struct A27_extra_size) == 1, "");
_Static_assert(sizeof(A28) == 128, "");
_Static_assert(_Alignof(A28) == 128, "");
_Static_assert(sizeof(struct A28_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A28_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A28_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A28_extra_packed) == 1, "");
_Static_assert(sizeof(struct A28_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A28_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A28_extra_size) == 130, "");
_Static_assert(_Alignof(struct A28_extra_size) == 1, "");
_Static_assert(sizeof(A29) == 128, "");
_Static_assert(_Alignof(A29) == 128, "");
_Static_assert(sizeof(struct A29_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A29_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A29_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A29_extra_packed) == 1, "");
_Static_assert(sizeof(struct A29_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A29_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A29_extra_size) == 130, "");
_Static_assert(_Alignof(struct A29_extra_size) == 1, "");
_Static_assert(sizeof(A30) == 128, "");
_Static_assert(_Alignof(A30) == 128, "");
_Static_assert(sizeof(struct A30_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A30_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A30_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A30_extra_packed) == 1, "");
_Static_assert(sizeof(struct A30_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A30_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A30_extra_size) == 130, "");
_Static_assert(_Alignof(struct A30_extra_size) == 1, "");
_Static_assert(sizeof(A31) == 128, "");
_Static_assert(_Alignof(A31) == 128, "");
_Static_assert(sizeof(struct A31_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A31_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A31_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A31_extra_packed) == 1, "");
_Static_assert(sizeof(struct A31_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A31_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A31_extra_size) == 130, "");
_Static_assert(_Alignof(struct A31_extra_size) == 1, "");
_Static_assert(sizeof(A32) == 128, "");
_Static_assert(_Alignof(A32) == 128, "");
_Static_assert(sizeof(struct A32_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A32_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A32_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A32_extra_packed) == 1, "");
_Static_assert(sizeof(struct A32_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A32_extra_size) == 130, "");
_Static_assert(_Alignof(struct A32_extra_size) == 1, "");
_Static_assert(sizeof(A33) == 128, "");
_Static_assert(_Alignof(A33) == 128, "");
_Static_assert(sizeof(struct A33_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A33_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A33_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A33_extra_packed) == 1, "");
_Static_assert(sizeof(struct A33_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A33_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A33_extra_size) == 130, "");
_Static_assert(_Alignof(struct A33_extra_size) == 1, "");
_Static_assert(sizeof(A34) == 128, "");
_Static_assert(_Alignof(A34) == 128, "");
_Static_assert(sizeof(struct A34_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A34_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A34_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A34_extra_packed) == 1, "");
_Static_assert(sizeof(struct A34_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A34_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A34_extra_size) == 130, "");
_Static_assert(_Alignof(struct A34_extra_size) == 1, "");
_Static_assert(sizeof(A35) == 128, "");
_Static_assert(_Alignof(A35) == 128, "");
_Static_assert(sizeof(struct A35_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A35_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A35_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A35_extra_packed) == 1, "");
_Static_assert(sizeof(struct A35_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A35_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A35_extra_size) == 130, "");
_Static_assert(_Alignof(struct A35_extra_size) == 1, "");
_Static_assert(sizeof(A36) == 128, "");
_Static_assert(_Alignof(A36) == 128, "");
_Static_assert(sizeof(struct A36_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A36_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A36_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A36_extra_packed) == 1, "");
_Static_assert(sizeof(struct A36_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A36_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A36_extra_size) == 130, "");
_Static_assert(_Alignof(struct A36_extra_size) == 1, "");
_Static_assert(sizeof(A37) == 128, "");
_Static_assert(_Alignof(A37) == 128, "");
_Static_assert(sizeof(struct A37_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A37_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A37_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A37_extra_packed) == 1, "");
_Static_assert(sizeof(struct A37_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A37_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A37_extra_size) == 130, "");
_Static_assert(_Alignof(struct A37_extra_size) == 1, "");
_Static_assert(sizeof(A38) == 128, "");
_Static_assert(_Alignof(A38) == 128, "");
_Static_assert(sizeof(struct A38_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A38_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A38_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A38_extra_packed) == 1, "");
_Static_assert(sizeof(struct A38_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A38_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A38_extra_size) == 130, "");
_Static_assert(_Alignof(struct A38_extra_size) == 1, "");
_Static_assert(sizeof(A39) == 128, "");
_Static_assert(_Alignof(A39) == 128, "");
_Static_assert(sizeof(struct A39_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A39_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A39_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A39_extra_packed) == 1, "");
_Static_assert(sizeof(struct A39_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A39_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A39_extra_size) == 130, "");
_Static_assert(_Alignof(struct A39_extra_size) == 1, "");
_Static_assert(sizeof(B00) == 128, "");
_Static_assert(_Alignof(B00) == 128, "");
_Static_assert(sizeof(struct B00_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B00_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B00_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B00_extra_packed) == 1, "");
_Static_assert(sizeof(struct B00_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B00_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B00_extra_size) == 130, "");
_Static_assert(_Alignof(struct B00_extra_size) == 1, "");
_Static_assert(sizeof(B01) == 8, "");
_Static_assert(_Alignof(B01) == 1, "");
_Static_assert(sizeof(struct B01_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B01_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B01_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B01_extra_packed) == 1, "");
_Static_assert(sizeof(struct B01_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B01_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B01_extra_size) == 10, "");
_Static_assert(_Alignof(struct B01_extra_size) == 1, "");
_Static_assert(sizeof(B02) == 8, "");
_Static_assert(_Alignof(B02) == 2, "");
_Static_assert(sizeof(struct B02_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B02_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B02_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B02_extra_packed) == 1, "");
_Static_assert(sizeof(struct B02_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B02_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B02_extra_size) == 10, "");
_Static_assert(_Alignof(struct B02_extra_size) == 1, "");
_Static_assert(sizeof(B03) == 128, "");
_Static_assert(_Alignof(B03) == 128, "");
_Static_assert(sizeof(struct B03_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B03_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B03_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B03_extra_packed) == 1, "");
_Static_assert(sizeof(struct B03_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B03_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B03_extra_size) == 130, "");
_Static_assert(_Alignof(struct B03_extra_size) == 1, "");
_Static_assert(sizeof(B04) == 8, "");
_Static_assert(_Alignof(B04) == 4, "");
_Static_assert(sizeof(struct B04_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B04_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B04_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B04_extra_packed) == 1, "");
_Static_assert(sizeof(struct B04_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B04_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B04_extra_size) == 10, "");
_Static_assert(_Alignof(struct B04_extra_size) == 1, "");
_Static_assert(sizeof(B05) == 128, "");
_Static_assert(_Alignof(B05) == 128, "");
_Static_assert(sizeof(struct B05_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B05_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B05_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B05_extra_packed) == 1, "");
_Static_assert(sizeof(struct B05_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B05_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B05_extra_size) == 130, "");
_Static_assert(_Alignof(struct B05_extra_size) == 1, "");
_Static_assert(sizeof(B06) == 128, "");
_Static_assert(_Alignof(B06) == 128, "");
_Static_assert(sizeof(struct B06_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B06_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B06_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B06_extra_packed) == 1, "");
_Static_assert(sizeof(struct B06_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B06_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B06_extra_size) == 130, "");
_Static_assert(_Alignof(struct B06_extra_size) == 1, "");
_Static_assert(sizeof(B07) == 128, "");
_Static_assert(_Alignof(B07) == 128, "");
_Static_assert(sizeof(struct B07_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B07_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B07_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B07_extra_packed) == 1, "");
_Static_assert(sizeof(struct B07_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B07_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B07_extra_size) == 130, "");
_Static_assert(_Alignof(struct B07_extra_size) == 1, "");
_Static_assert(sizeof(B08) == 8, "");
_Static_assert(_Alignof(B08) == 8, "");
_Static_assert(sizeof(struct B08_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B08_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B08_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B08_extra_packed) == 1, "");
_Static_assert(sizeof(struct B08_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B08_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B08_extra_size) == 10, "");
_Static_assert(_Alignof(struct B08_extra_size) == 1, "");
_Static_assert(sizeof(B09) == 128, "");
_Static_assert(_Alignof(B09) == 128, "");
_Static_assert(sizeof(struct B09_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B09_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B09_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B09_extra_packed) == 1, "");
_Static_assert(sizeof(struct B09_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B09_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B09_extra_size) == 130, "");
_Static_assert(_Alignof(struct B09_extra_size) == 1, "");
_Static_assert(sizeof(B10) == 128, "");
_Static_assert(_Alignof(B10) == 128, "");
_Static_assert(sizeof(struct B10_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B10_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B10_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B10_extra_packed) == 1, "");
_Static_assert(sizeof(struct B10_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B10_extra_size) == 130, "");
_Static_assert(_Alignof(struct B10_extra_size) == 1, "");
_Static_assert(sizeof(B11) == 128, "");
_Static_assert(_Alignof(B11) == 128, "");
_Static_assert(sizeof(struct B11_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B11_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B11_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B11_extra_packed) == 1, "");
_Static_assert(sizeof(struct B11_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B11_extra_size) == 130, "");
_Static_assert(_Alignof(struct B11_extra_size) == 1, "");
_Static_assert(sizeof(B12) == 128, "");
_Static_assert(_Alignof(B12) == 128, "");
_Static_assert(sizeof(struct B12_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B12_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B12_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B12_extra_packed) == 1, "");
_Static_assert(sizeof(struct B12_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B12_extra_size) == 130, "");
_Static_assert(_Alignof(struct B12_extra_size) == 1, "");
_Static_assert(sizeof(B13) == 128, "");
_Static_assert(_Alignof(B13) == 128, "");
_Static_assert(sizeof(struct B13_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B13_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B13_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B13_extra_packed) == 1, "");
_Static_assert(sizeof(struct B13_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B13_extra_size) == 130, "");
_Static_assert(_Alignof(struct B13_extra_size) == 1, "");
_Static_assert(sizeof(B14) == 128, "");
_Static_assert(_Alignof(B14) == 128, "");
_Static_assert(sizeof(struct B14_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B14_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B14_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B14_extra_packed) == 1, "");
_Static_assert(sizeof(struct B14_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B14_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B14_extra_size) == 130, "");
_Static_assert(_Alignof(struct B14_extra_size) == 1, "");
_Static_assert(sizeof(B15) == 128, "");
_Static_assert(_Alignof(B15) == 128, "");
_Static_assert(sizeof(struct B15_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B15_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B15_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B15_extra_packed) == 1, "");
_Static_assert(sizeof(struct B15_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B15_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B15_extra_size) == 130, "");
_Static_assert(_Alignof(struct B15_extra_size) == 1, "");
_Static_assert(sizeof(B16) == 16, "");
_Static_assert(_Alignof(B16) == 16, "");
_Static_assert(sizeof(struct B16_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B16_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B16_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B16_extra_packed) == 1, "");
_Static_assert(sizeof(struct B16_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B16_extra_size) == 18, "");
_Static_assert(_Alignof(struct B16_extra_size) == 1, "");
_Static_assert(sizeof(B17) == 128, "");
_Static_assert(_Alignof(B17) == 128, "");
_Static_assert(sizeof(struct B17_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B17_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B17_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B17_extra_packed) == 1, "");
_Static_assert(sizeof(struct B17_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B17_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B17_extra_size) == 130, "");
_Static_assert(_Alignof(struct B17_extra_size) == 1, "");
_Static_assert(sizeof(B18) == 128, "");
_Static_assert(_Alignof(B18) == 128, "");
_Static_assert(sizeof(struct B18_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B18_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B18_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B18_extra_packed) == 1, "");
_Static_assert(sizeof(struct B18_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B18_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B18_extra_size) == 130, "");
_Static_assert(_Alignof(struct B18_extra_size) == 1, "");
_Static_assert(sizeof(B19) == 128, "");
_Static_assert(_Alignof(B19) == 128, "");
_Static_assert(sizeof(struct B19_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B19_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B19_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B19_extra_packed) == 1, "");
_Static_assert(sizeof(struct B19_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B19_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B19_extra_size) == 130, "");
_Static_assert(_Alignof(struct B19_extra_size) == 1, "");
_Static_assert(sizeof(B20) == 128, "");
_Static_assert(_Alignof(B20) == 128, "");
_Static_assert(sizeof(struct B20_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B20_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B20_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B20_extra_packed) == 1, "");
_Static_assert(sizeof(struct B20_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B20_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B20_extra_size) == 130, "");
_Static_assert(_Alignof(struct B20_extra_size) == 1, "");
_Static_assert(sizeof(B21) == 128, "");
_Static_assert(_Alignof(B21) == 128, "");
_Static_assert(sizeof(struct B21_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B21_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B21_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B21_extra_packed) == 1, "");
_Static_assert(sizeof(struct B21_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B21_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B21_extra_size) == 130, "");
_Static_assert(_Alignof(struct B21_extra_size) == 1, "");
_Static_assert(sizeof(B22) == 128, "");
_Static_assert(_Alignof(B22) == 128, "");
_Static_assert(sizeof(struct B22_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B22_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B22_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B22_extra_packed) == 1, "");
_Static_assert(sizeof(struct B22_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B22_extra_size) == 130, "");
_Static_assert(_Alignof(struct B22_extra_size) == 1, "");
_Static_assert(sizeof(B23) == 128, "");
_Static_assert(_Alignof(B23) == 128, "");
_Static_assert(sizeof(struct B23_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B23_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B23_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B23_extra_packed) == 1, "");
_Static_assert(sizeof(struct B23_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B23_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B23_extra_size) == 130, "");
_Static_assert(_Alignof(struct B23_extra_size) == 1, "");
_Static_assert(sizeof(B24) == 128, "");
_Static_assert(_Alignof(B24) == 128, "");
_Static_assert(sizeof(struct B24_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B24_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B24_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B24_extra_packed) == 1, "");
_Static_assert(sizeof(struct B24_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B24_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B24_extra_size) == 130, "");
_Static_assert(_Alignof(struct B24_extra_size) == 1, "");
_Static_assert(sizeof(B25) == 128, "");
_Static_assert(_Alignof(B25) == 128, "");
_Static_assert(sizeof(struct B25_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B25_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B25_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B25_extra_packed) == 1, "");
_Static_assert(sizeof(struct B25_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B25_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B25_extra_size) == 130, "");
_Static_assert(_Alignof(struct B25_extra_size) == 1, "");
_Static_assert(sizeof(B26) == 128, "");
_Static_assert(_Alignof(B26) == 128, "");
_Static_assert(sizeof(struct B26_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B26_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B26_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B26_extra_packed) == 1, "");
_Static_assert(sizeof(struct B26_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B26_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B26_extra_size) == 130, "");
_Static_assert(_Alignof(struct B26_extra_size) == 1, "");
_Static_assert(sizeof(B27) == 128, "");
_Static_assert(_Alignof(B27) == 128, "");
_Static_assert(sizeof(struct B27_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B27_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B27_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B27_extra_packed) == 1, "");
_Static_assert(sizeof(struct B27_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B27_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B27_extra_size) == 130, "");
_Static_assert(_Alignof(struct B27_extra_size) == 1, "");
_Static_assert(sizeof(B28) == 128, "");
_Static_assert(_Alignof(B28) == 128, "");
_Static_assert(sizeof(struct B28_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B28_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B28_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B28_extra_packed) == 1, "");
_Static_assert(sizeof(struct B28_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B28_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B28_extra_size) == 130, "");
_Static_assert(_Alignof(struct B28_extra_size) == 1, "");
_Static_assert(sizeof(B29) == 128, "");
_Static_assert(_Alignof(B29) == 128, "");
_Static_assert(sizeof(struct B29_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B29_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B29_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B29_extra_packed) == 1, "");
_Static_assert(sizeof(struct B29_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B29_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B29_extra_size) == 130, "");
_Static_assert(_Alignof(struct B29_extra_size) == 1, "");
_Static_assert(sizeof(B30) == 128, "");
_Static_assert(_Alignof(B30) == 128, "");
_Static_assert(sizeof(struct B30_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B30_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B30_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B30_extra_packed) == 1, "");
_Static_assert(sizeof(struct B30_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B30_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B30_extra_size) == 130, "");
_Static_assert(_Alignof(struct B30_extra_size) == 1, "");
_Static_assert(sizeof(B31) == 128, "");
_Static_assert(_Alignof(B31) == 128, "");
_Static_assert(sizeof(struct B31_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B31_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B31_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B31_extra_packed) == 1, "");
_Static_assert(sizeof(struct B31_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B31_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B31_extra_size) == 130, "");
_Static_assert(_Alignof(struct B31_extra_size) == 1, "");
_Static_assert(sizeof(B32) == 128, "");
_Static_assert(_Alignof(B32) == 128, "");
_Static_assert(sizeof(struct B32_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B32_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B32_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B32_extra_packed) == 1, "");
_Static_assert(sizeof(struct B32_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B32_extra_size) == 130, "");
_Static_assert(_Alignof(struct B32_extra_size) == 1, "");
_Static_assert(sizeof(B33) == 128, "");
_Static_assert(_Alignof(B33) == 128, "");
_Static_assert(sizeof(struct B33_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B33_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B33_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B33_extra_packed) == 1, "");
_Static_assert(sizeof(struct B33_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B33_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B33_extra_size) == 130, "");
_Static_assert(_Alignof(struct B33_extra_size) == 1, "");
_Static_assert(sizeof(B34) == 128, "");
_Static_assert(_Alignof(B34) == 128, "");
_Static_assert(sizeof(struct B34_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B34_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B34_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B34_extra_packed) == 1, "");
_Static_assert(sizeof(struct B34_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B34_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B34_extra_size) == 130, "");
_Static_assert(_Alignof(struct B34_extra_size) == 1, "");
_Static_assert(sizeof(B35) == 128, "");
_Static_assert(_Alignof(B35) == 128, "");
_Static_assert(sizeof(struct B35_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B35_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B35_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B35_extra_packed) == 1, "");
_Static_assert(sizeof(struct B35_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B35_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B35_extra_size) == 130, "");
_Static_assert(_Alignof(struct B35_extra_size) == 1, "");
_Static_assert(sizeof(B36) == 128, "");
_Static_assert(_Alignof(B36) == 128, "");
_Static_assert(sizeof(struct B36_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B36_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B36_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B36_extra_packed) == 1, "");
_Static_assert(sizeof(struct B36_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B36_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B36_extra_size) == 130, "");
_Static_assert(_Alignof(struct B36_extra_size) == 1, "");
_Static_assert(sizeof(B37) == 128, "");
_Static_assert(_Alignof(B37) == 128, "");
_Static_assert(sizeof(struct B37_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B37_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B37_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B37_extra_packed) == 1, "");
_Static_assert(sizeof(struct B37_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B37_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B37_extra_size) == 130, "");
_Static_assert(_Alignof(struct B37_extra_size) == 1, "");
_Static_assert(sizeof(B38) == 128, "");
_Static_assert(_Alignof(B38) == 128, "");
_Static_assert(sizeof(struct B38_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B38_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B38_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B38_extra_packed) == 1, "");
_Static_assert(sizeof(struct B38_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B38_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B38_extra_size) == 130, "");
_Static_assert(_Alignof(struct B38_extra_size) == 1, "");
_Static_assert(sizeof(B39) == 128, "");
_Static_assert(_Alignof(B39) == 128, "");
_Static_assert(sizeof(struct B39_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B39_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B39_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B39_extra_packed) == 1, "");
_Static_assert(sizeof(struct B39_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B39_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B39_extra_size) == 130, "");
_Static_assert(_Alignof(struct B39_extra_size) == 1, "");
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A00) == 128, "");
_Static_assert(_Alignof(A00) == 128, "");
_Static_assert(sizeof(struct A00_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A00_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A00_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A00_extra_packed) == 1, "");
_Static_assert(sizeof(struct A00_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A00_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A00_extra_size) == 130, "");
_Static_assert(_Alignof(struct A00_extra_size) == 1, "");
_Static_assert(sizeof(A01) == 8, "");
_Static_assert(_Alignof(A01) == 1, "");
_Static_assert(sizeof(struct A01_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A01_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A01_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A01_extra_packed) == 1, "");
_Static_assert(sizeof(struct A01_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A01_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A01_extra_size) == 10, "");
_Static_assert(_Alignof(struct A01_extra_size) == 1, "");
_Static_assert(sizeof(A02) == 8, "");
_Static_assert(_Alignof(A02) == 2, "");
_Static_assert(sizeof(struct A02_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A02_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A02_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A02_extra_packed) == 1, "");
_Static_assert(sizeof(struct A02_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A02_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A02_extra_size) == 10, "");
_Static_assert(_Alignof(struct A02_extra_size) == 1, "");
_Static_assert(sizeof(A03) == 128, "");
_Static_assert(_Alignof(A03) == 128, "");
_Static_assert(sizeof(struct A03_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A03_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A03_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A03_extra_packed) == 1, "");
_Static_assert(sizeof(struct A03_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A03_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A03_extra_size) == 130, "");
_Static_assert(_Alignof(struct A03_extra_size) == 1, "");
_Static_assert(sizeof(A04) == 8, "");
_Static_assert(_Alignof(A04) == 4, "");
_Static_assert(sizeof(struct A04_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A04_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A04_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A04_extra_packed) == 1, "");
_Static_assert(sizeof(struct A04_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A04_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A04_extra_size) == 10, "");
_Static_assert(_Alignof(struct A04_extra_size) == 1, "");
_Static_assert(sizeof(A05) == 128, "");
_Static_assert(_Alignof(A05) == 128, "");
_Static_assert(sizeof(struct A05_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A05_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A05_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A05_extra_packed) == 1, "");
_Static_assert(sizeof(struct A05_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A05_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A05_extra_size) == 130, "");
_Static_assert(_Alignof(struct A05_extra_size) == 1, "");
_Static_assert(sizeof(A06) == 128, "");
_Static_assert(_Alignof(A06) == 128, "");
_Static_assert(sizeof(struct A06_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A06_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A06_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A06_extra_packed) == 1, "");
_Static_assert(sizeof(struct A06_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A06_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A06_extra_size) == 130, "");
_Static_assert(_Alignof(struct A06_extra_size) == 1, "");
_Static_assert(sizeof(A07) == 128, "");
_Static_assert(_Alignof(A07) == 128, "");
_Static_assert(sizeof(struct A07_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A07_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A07_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A07_extra_packed) == 1, "");
_Static_assert(sizeof(struct A07_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A07_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A07_extra_size) == 130, "");
_Static_assert(_Alignof(struct A07_extra_size) == 1, "");
_Static_assert(sizeof(A08) == 8, "");
_Static_assert(_Alignof(A08) == 8, "");
_Static_assert(sizeof(struct A08_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A08_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A08_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A08_extra_packed) == 1, "");
_Static_assert(sizeof(struct A08_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A08_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A08_extra_size) == 10, "");
_Static_assert(_Alignof(struct A08_extra_size) == 1, "");
_Static_assert(sizeof(A09) == 128, "");
_Static_assert(_Alignof(A09) == 128, "");
_Static_assert(sizeof(struct A09_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A09_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A09_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A09_extra_packed) == 1, "");
_Static_assert(sizeof(struct A09_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A09_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A09_extra_size) == 130, "");
_Static_assert(_Alignof(struct A09_extra_size) == 1, "");
_Static_assert(sizeof(A10) == 128, "");
_Static_assert(_Alignof(A10) == 128, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A10_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 130, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 128, "");
_Static_assert(_Alignof(A11) == 128, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A11_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 130, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
_Static_assert(sizeof(A12) == 128, "");
_Static_assert(_Alignof(A12) == 128, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A12_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 130, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
_Static_assert(sizeof(A13) == 128, "");
_Static_assert(_Alignof(A13) == 128, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A13_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 130, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
_Static_assert(sizeof(A14) == 128, "");
_Static_assert(_Alignof(A14) == 128, "");
_Static_assert(sizeof(struct A14_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A14_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A14_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A14_extra_packed) == 1, "");
_Static_assert(sizeof(struct A14_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A14_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A14_extra_size) == 130, "");
_Static_assert(_Alignof(struct A14_extra_size) == 1, "");
_Static_assert(sizeof(A15) == 128, "");
_Static_assert(_Alignof(A15) == 128, "");
_Static_assert(sizeof(struct A15_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A15_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A15_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A15_extra_packed) == 1, "");
_Static_assert(sizeof(struct A15_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A15_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A15_extra_size) == 130, "");
_Static_assert(_Alignof(struct A15_extra_size) == 1, "");
_Static_assert(sizeof(A16) == 16, "");
_Static_assert(_Alignof(A16) == 16, "");
_Static_assert(sizeof(struct A16_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A16_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A16_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A16_extra_packed) == 1, "");
_Static_assert(sizeof(struct A16_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A16_extra_size) == 18, "");
_Static_assert(_Alignof(struct A16_extra_size) == 1, "");
_Static_assert(sizeof(A17) == 128, "");
_Static_assert(_Alignof(A17) == 128, "");
_Static_assert(sizeof(struct A17_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A17_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A17_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A17_extra_packed) == 1, "");
_Static_assert(sizeof(struct A17_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A17_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A17_extra_size) == 130, "");
_Static_assert(_Alignof(struct A17_extra_size) == 1, "");
_Static_assert(sizeof(A18) == 128, "");
_Static_assert(_Alignof(A18) == 128, "");
_Static_assert(sizeof(struct A18_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A18_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A18_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A18_extra_packed) == 1, "");
_Static_assert(sizeof(struct A18_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A18_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A18_extra_size) == 130, "");
_Static_assert(_Alignof(struct A18_extra_size) == 1, "");
_Static_assert(sizeof(A19) == 128, "");
_Static_assert(_Alignof(A19) == 128, "");
_Static_assert(sizeof(struct A19_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A19_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A19_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A19_extra_packed) == 1, "");
_Static_assert(sizeof(struct A19_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A19_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A19_extra_size) == 130, "");
_Static_assert(_Alignof(struct A19_extra_size) == 1, "");
_Static_assert(sizeof(A20) == 128, "");
_Static_assert(_Alignof(A20) == 128, "");
_Static_assert(sizeof(struct A20_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A20_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A20_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A20_extra_packed) == 1, "");
_Static_assert(sizeof(struct A20_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A20_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A20_extra_size) == 130, "");
_Static_assert(_Alignof(struct A20_extra_size) == 1, "");
_Static_assert(sizeof(A21) == 128, "");
_Static_assert(_Alignof(A21) == 128, "");
_Static_assert(sizeof(struct A21_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A21_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A21_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A21_extra_packed) == 1, "");
_Static_assert(sizeof(struct A21_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A21_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A21_extra_size) == 130, "");
_Static_assert(_Alignof(struct A21_extra_size) == 1, "");
_Static_assert(sizeof(A22) == 128, "");
_Static_assert(_Alignof(A22) == 128, "");
_Static_assert(sizeof(struct A22_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A22_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A22_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A22_extra_packed) == 1, "");
_Static_assert(sizeof(struct A22_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A22_extra_size) == 130, "");
_Static_assert(_Alignof(struct A22_extra_size) == 1, "");
_Static_assert(sizeof(A23) == 128, "");
_Static_assert(_Alignof(A23) == 128, "");
_Static_assert(sizeof(struct A23_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A23_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A23_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A23_extra_packed) == 1, "");
_Static_assert(sizeof(struct A23_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A23_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A23_extra_size) == 130, "");
_Static_assert(_Alignof(struct A23_extra_size) == 1, "");
_Static_assert(sizeof(A24) == 128, "");
_Static_assert(_Alignof(A24) == 128, "");
_Static_assert(sizeof(struct A24_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A24_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A24_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A24_extra_packed) == 1, "");
_Static_assert(sizeof(struct A24_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A24_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A24_extra_size) == 130, "");
_Static_assert(_Alignof(struct A24_extra_size) == 1, "");
_Static_assert(sizeof(A25) == 128, "");
_Static_assert(_Alignof(A25) == 128, "");
_Static_assert(sizeof(struct A25_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A25_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A25_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A25_extra_packed) == 1, "");
_Static_assert(sizeof(struct A25_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A25_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A25_extra_size) == 130, "");
_Static_assert(_Alignof(struct A25_extra_size) == 1, "");
_Static_assert(sizeof(A26) == 128, "");
_Static_assert(_Alignof(A26) == 128, "");
_Static_assert(sizeof(struct A26_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A26_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A26_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A26_extra_packed) == 1, "");
_Static_assert(sizeof(struct A26_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A26_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A26_extra_size) == 130, "");
_Static_assert(_Alignof(struct A26_extra_size) == 1, "");
_Static_assert(sizeof(A27) == 128, "");
_Static_assert(_Alignof(A27) == 128, "");
_Static_assert(sizeof(struct A27_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A27_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A27_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A27_extra_packed) == 1, "");
_Static_assert(sizeof(struct A27_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A27_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A27_extra_size) == 130, "");
_Static_assert(_Alignof(struct A27_extra_size) == 1, "");
_Static_assert(sizeof(A28) == 128, "");
_Static_assert(_Alignof(A28) == 128, "");
_Static_assert(sizeof(struct A28_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A28_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A28_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A28_extra_packed) == 1, "");
_Static_assert(sizeof(struct A28_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A28_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A28_extra_size) == 130, "");
_Static_assert(_Alignof(struct A28_extra_size) == 1, "");
_Static_assert(sizeof(A29) == 128, "");
_Static_assert(_Alignof(A29) == 128, "");
_Static_assert(sizeof(struct A29_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A29_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A29_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A29_extra_packed) == 1, "");
_Static_assert(sizeof(struct A29_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A29_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A29_extra_size) == 130, "");
_Static_assert(_Alignof(struct A29_extra_size) == 1, "");
_Static_assert(sizeof(A30) == 128, "");
_Static_assert(_Alignof(A30) == 128, "");
_Static_assert(sizeof(struct A30_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A30_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A30_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A30_extra_packed) == 1, "");
_Static_assert(sizeof(struct A30_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A30_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A30_extra_size) == 130, "");
_Static_assert(_Alignof(struct A30_extra_size) == 1, "");
_Static_assert(sizeof(A31) == 128, "");
_Static_assert(_Alignof(A31) == 128, "");
_Static_assert(sizeof(struct A31_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A31_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A31_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A31_extra_packed) == 1, "");
_Static_assert(sizeof(struct A31_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A31_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A31_extra_size) == 130, "");
_Static_assert(_Alignof(struct A31_extra_size) == 1, "");
_Static_assert(sizeof(A32) == 128, "");
_Static_assert(_Alignof(A32) == 128, "");
_Static_assert(sizeof(struct A32_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A32_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A32_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A32_extra_packed) == 1, "");
_Static_assert(sizeof(struct A32_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A32_extra_size) == 130, "");
_Static_assert(_Alignof(struct A32_extra_size) == 1, "");
_Static_assert(sizeof(A33) == 128, "");
_Static_assert(_Alignof(A33) == 128, "");
_Static_assert(sizeof(struct A33_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A33_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A33_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A33_extra_packed) == 1, "");
_Static_assert(sizeof(struct A33_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A33_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A33_extra_size) == 130, "");
_Static_assert(_Alignof(struct A33_extra_size) == 1, "");
_Static_assert(sizeof(A34) == 128, "");
_Static_assert(_Alignof(A34) == 128, "");
_Static_assert(sizeof(struct A34_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A34_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A34_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A34_extra_packed) == 1, "");
_Static_assert(sizeof(struct A34_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A34_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A34_extra_size) == 130, "");
_Static_assert(_Alignof(struct A34_extra_size) == 1, "");
_Static_assert(sizeof(A35) == 128, "");
_Static_assert(_Alignof(A35) == 128, "");
_Static_assert(sizeof(struct A35_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A35_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A35_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A35_extra_packed) == 1, "");
_Static_assert(sizeof(struct A35_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A35_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A35_extra_size) == 130, "");
_Static_assert(_Alignof(struct A35_extra_size) == 1, "");
_Static_assert(sizeof(A36) == 128, "");
_Static_assert(_Alignof(A36) == 128, "");
_Static_assert(sizeof(struct A36_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A36_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A36_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A36_extra_packed) == 1, "");
_Static_assert(sizeof(struct A36_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A36_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A36_extra_size) == 130, "");
_Static_assert(_Alignof(struct A36_extra_size) == 1, "");
_Static_assert(sizeof(A37) == 128, "");
_Static_assert(_Alignof(A37) == 128, "");
_Static_assert(sizeof(struct A37_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A37_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A37_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A37_extra_packed) == 1, "");
_Static_assert(sizeof(struct A37_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A37_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A37_extra_size) == 130, "");
_Static_assert(_Alignof(struct A37_extra_size) == 1, "");
_Static_assert(sizeof(A38) == 128, "");
_Static_assert(_Alignof(A38) == 128, "");
_Static_assert(sizeof(struct A38_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A38_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A38_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A38_extra_packed) == 1, "");
_Static_assert(sizeof(struct A38_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A38_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A38_extra_size) == 130, "");
_Static_assert(_Alignof(struct A38_extra_size) == 1, "");
_Static_assert(sizeof(A39) == 128, "");
_Static_assert(_Alignof(A39) == 128, "");
_Static_assert(sizeof(struct A39_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A39_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A39_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A39_extra_packed) == 1, "");
_Static_assert(sizeof(struct A39_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A39_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A39_extra_size) == 130, "");
_Static_assert(_Alignof(struct A39_extra_size) == 1, "");
_Static_assert(sizeof(B00) == 128, "");
_Static_assert(_Alignof(B00) == 128, "");
_Static_assert(sizeof(struct B00_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B00_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B00_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B00_extra_packed) == 1, "");
_Static_assert(sizeof(struct B00_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B00_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B00_extra_size) == 130, "");
_Static_assert(_Alignof(struct B00_extra_size) == 1, "");
_Static_assert(sizeof(B01) == 8, "");
_Static_assert(_Alignof(B01) == 1, "");
_Static_assert(sizeof(struct B01_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B01_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B01_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B01_extra_packed) == 1, "");
_Static_assert(sizeof(struct B01_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B01_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B01_extra_size) == 10, "");
_Static_assert(_Alignof(struct B01_extra_size) == 1, "");
_Static_assert(sizeof(B02) == 8, "");
_Static_assert(_Alignof(B02) == 2, "");
_Static_assert(sizeof(struct B02_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B02_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B02_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B02_extra_packed) == 1, "");
_Static_assert(sizeof(struct B02_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B02_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B02_extra_size) == 10, "");
_Static_assert(_Alignof(struct B02_extra_size) == 1, "");
_Static_assert(sizeof(B03) == 128, "");
_Static_assert(_Alignof(B03) == 128, "");
_Static_assert(sizeof(struct B03_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B03_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B03_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B03_extra_packed) == 1, "");
_Static_assert(sizeof(struct B03_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B03_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B03_extra_size) == 130, "");
_Static_assert(_Alignof(struct B03_extra_size) == 1, "");
_Static_assert(sizeof(B04) == 8, "");
_Static_assert(_Alignof(B04) == 4, "");
_Static_assert(sizeof(struct B04_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B04_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B04_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B04_extra_packed) == 1, "");
_Static_assert(sizeof(struct B04_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B04_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B04_extra_size) == 10, "");
_Static_assert(_Alignof(struct B04_extra_size) == 1, "");
_Static_assert(sizeof(B05) == 128, "");
_Static_assert(_Alignof(B05) == 128, "");
_Static_assert(sizeof(struct B05_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B05_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B05_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B05_extra_packed) == 1, "");
_Static_assert(sizeof(struct B05_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B05_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B05_extra_size) == 130, "");
_Static_assert(_Alignof(struct B05_extra_size) == 1, "");
_Static_assert(sizeof(B06) == 128, "");
_Static_assert(_Alignof(B06) == 128, "");
_Static_assert(sizeof(struct B06_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B06_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B06_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B06_extra_packed) == 1, "");
_Static_assert(sizeof(struct B06_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B06_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B06_extra_size) == 130, "");
_Static_assert(_Alignof(struct B06_extra_size) == 1, "");
_Static_assert(sizeof(B07) == 128, "");
_Static_assert(_Alignof(B07) == 128, "");
_Static_assert(sizeof(struct B07_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B07_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B07_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B07_extra_packed) == 1, "");
_Static_assert(sizeof(struct B07_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B07_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B07_extra_size) == 130, "");
_Static_assert(_Alignof(struct B07_extra_size) == 1, "");
_Static_assert(sizeof(B08) == 8, "");
_Static_assert(_Alignof(B08) == 8, "");
_Static_assert(sizeof(struct B08_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B08_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B08_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B08_extra_packed) == 1, "");
_Static_assert(sizeof(struct B08_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B08_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B08_extra_size) == 10, "");
_Static_assert(_Alignof(struct B08_extra_size) == 1, "");
_Static_assert(sizeof(B09) == 128, "");
_Static_assert(_Alignof(B09) == 128, "");
_Static_assert(sizeof(struct B09_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B09_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B09_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B09_extra_packed) == 1, "");
_Static_assert(sizeof(struct B09_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B09_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B09_extra_size) == 130, "");
_Static_assert(_Alignof(struct B09_extra_size) == 1, "");
_Static_assert(sizeof(B10) == 128, "");
_Static_assert(_Alignof(B10) == 128, "");
_Static_assert(sizeof(struct B10_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B10_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B10_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B10_extra_packed) == 1, "");
_Static_assert(sizeof(struct B10_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B10_extra_size) == 130, "");
_Static_assert(_Alignof(struct B10_extra_size) == 1, "");
_Static_assert(sizeof(B11) == 128, "");
_Static_assert(_Alignof(B11) == 128, "");
_Static_assert(sizeof(struct B11_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B11_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B11_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B11_extra_packed) == 1, "");
_Static_assert(sizeof(struct B11_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B11_extra_size) == 130, "");
_Static_assert(_Alignof(struct B11_extra_size) == 1, "");
_Static_assert(sizeof(B12) == 128, "");
_Static_assert(_Alignof(B12) == 128, "");
_Static_assert(sizeof(struct B12_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B12_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B12_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B12_extra_packed) == 1, "");
_Static_assert(sizeof(struct B12_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B12_extra_size) == 130, "");
_Static_assert(_Alignof(struct B12_extra_size) == 1, "");
_Static_assert(sizeof(B13) == 128, "");
_Static_assert(_Alignof(B13) == 128, "");
_Static_assert(sizeof(struct B13_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B13_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B13_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B13_extra_packed) == 1, "");
_Static_assert(sizeof(struct B13_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B13_extra_size) == 130, "");
_Static_assert(_Alignof(struct B13_extra_size) == 1, "");
_Static_assert(sizeof(B14) == 128, "");
_Static_assert(_Alignof(B14) == 128, "");
_Static_assert(sizeof(struct B14_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B14_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B14_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B14_extra_packed) == 1, "");
_Static_assert(sizeof(struct B14_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B14_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B14_extra_size) == 130, "");
_Static_assert(_Alignof(struct B14_extra_size) == 1, "");
_Static_assert(sizeof(B15) == 128, "");
_Static_assert(_Alignof(B15) == 128, "");
_Static_assert(sizeof(struct B15_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B15_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B15_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B15_extra_packed) == 1, "");
_Static_assert(sizeof(struct B15_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B15_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B15_extra_size) == 130, "");
_Static_assert(_Alignof(struct B15_extra_size) == 1, "");
_Static_assert(sizeof(B16) == 16, "");
_Static_assert(_Alignof(B16) == 16, "");
_Static_assert(sizeof(struct B16_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B16_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B16_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B16_extra_packed) == 1, "");
_Static_assert(sizeof(struct B16_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B16_extra_size) == 18, "");
_Static_assert(_Alignof(struct B16_extra_size) == 1, "");
_Static_assert(sizeof(B17) == 128, "");
_Static_assert(_Alignof(B17) == 128, "");
_Static_assert(sizeof(struct B17_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B17_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B17_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B17_extra_packed) == 1, "");
_Static_assert(sizeof(struct B17_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B17_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B17_extra_size) == 130, "");
_Static_assert(_Alignof(struct B17_extra_size) == 1, "");
_Static_assert(sizeof(B18) == 128, "");
_Static_assert(_Alignof(B18) == 128, "");
_Static_assert(sizeof(struct B18_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B18_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B18_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B18_extra_packed) == 1, "");
_Static_assert(sizeof(struct B18_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B18_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B18_extra_size) == 130, "");
_Static_assert(_Alignof(struct B18_extra_size) == 1, "");
_Static_assert(sizeof(B19) == 128, "");
_Static_assert(_Alignof(B19) == 128, "");
_Static_assert(sizeof(struct B19_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B19_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B19_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B19_extra_packed) == 1, "");
_Static_assert(sizeof(struct B19_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B19_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B19_extra_size) == 130, "");
_Static_assert(_Alignof(struct B19_extra_size) == 1, "");
_Static_assert(sizeof(B20) == 128, "");
_Static_assert(_Alignof(B20) == 128, "");
_Static_assert(sizeof(struct B20_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B20_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B20_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B20_extra_packed) == 1, "");
_Static_assert(sizeof(struct B20_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B20_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B20_extra_size) == 130, "");
_Static_assert(_Alignof(struct B20_extra_size) == 1, "");
_Static_assert(sizeof(B21) == 128, "");
_Static_assert(_Alignof(B21) == 128, "");
_Static_assert(sizeof(struct B21_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B21_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B21_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B21_extra_packed) == 1, "");
_Static_assert(sizeof(struct B21_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B21_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B21_extra_size) == 130, "");
_Static_assert(_Alignof(struct B21_extra_size) == 1, "");
_Static_assert(sizeof(B22) == 128, "");
_Static_assert(_Alignof(B22) == 128, "");
_Static_assert(sizeof(struct B22_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B22_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B22_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B22_extra_packed) == 1, "");
_Static_assert(sizeof(struct B22_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B22_extra_size) == 130, "");
_Static_assert(_Alignof(struct B22_extra_size) == 1, "");
_Static_assert(sizeof(B23) == 128, "");
_Static_assert(_Alignof(B23) == 128, "");
_Static_assert(sizeof(struct B23_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B23_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B23_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B23_extra_packed) == 1, "");
_Static_assert(sizeof(struct B23_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B23_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B23_extra_size) == 130, "");
_Static_assert(_Alignof(struct B23_extra_size) == 1, "");
_Static_assert(sizeof(B24) == 128, "");
_Static_assert(_Alignof(B24) == 128, "");
_Static_assert(sizeof(struct B24_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B24_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B24_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B24_extra_packed) == 1, "");
_Static_assert(sizeof(struct B24_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B24_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B24_extra_size) == 130, "");
_Static_assert(_Alignof(struct B24_extra_size) == 1, "");
_Static_assert(sizeof(B25) == 128, "");
_Static_assert(_Alignof(B25) == 128, "");
_Static_assert(sizeof(struct B25_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B25_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B25_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B25_extra_packed) == 1, "");
_Static_assert(sizeof(struct B25_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B25_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B25_extra_size) == 130, "");
_Static_assert(_Alignof(struct B25_extra_size) == 1, "");
_Static_assert(sizeof(B26) == 128, "");
_Static_assert(_Alignof(B26) == 128, "");
_Static_assert(sizeof(struct B26_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B26_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B26_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B26_extra_packed) == 1, "");
_Static_assert(sizeof(struct B26_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B26_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B26_extra_size) == 130, "");
_Static_assert(_Alignof(struct B26_extra_size) == 1, "");
_Static_assert(sizeof(B27) == 128, "");
_Static_assert(_Alignof(B27) == 128, "");
_Static_assert(sizeof(struct B27_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B27_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B27_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B27_extra_packed) == 1, "");
_Static_assert(sizeof(struct B27_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B27_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B27_extra_size) == 130, "");
_Static_assert(_Alignof(struct B27_extra_size) == 1, "");
_Static_assert(sizeof(B28) == 128, "");
_Static_assert(_Alignof(B28) == 128, "");
_Static_assert(sizeof(struct B28_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B28_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B28_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B28_extra_packed) == 1, "");
_Static_assert(sizeof(struct B28_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B28_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B28_extra_size) == 130, "");
_Static_assert(_Alignof(struct B28_extra_size) == 1, "");
_Static_assert(sizeof(B29) == 128, "");
_Static_assert(_Alignof(B29) == 128, "");
_Static_assert(sizeof(struct B29_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B29_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B29_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B29_extra_packed) == 1, "");
_Static_assert(sizeof(struct B29_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B29_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B29_extra_size) == 130, "");
_Static_assert(_Alignof(struct B29_extra_size) == 1, "");
_Static_assert(sizeof(B30) == 128, "");
_Static_assert(_Alignof(B30) == 128, "");
_Static_assert(sizeof(struct B30_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B30_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B30_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B30_extra_packed) == 1, "");
_Static_assert(sizeof(struct B30_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B30_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B30_extra_size) == 130, "");
_Static_assert(_Alignof(struct B30_extra_size) == 1, "");
_Static_assert(sizeof(B31) == 128, "");
_Static_assert(_Alignof(B31) == 128, "");
_Static_assert(sizeof(struct B31_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B31_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B31_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B31_extra_packed) == 1, "");
_Static_assert(sizeof(struct B31_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B31_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B31_extra_size) == 130, "");
_Static_assert(_Alignof(struct B31_extra_size) == 1, "");
_Static_assert(sizeof(B32) == 128, "");
_Static_assert(_Alignof(B32) == 128, "");
_Static_assert(sizeof(struct B32_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B32_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B32_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B32_extra_packed) == 1, "");
_Static_assert(sizeof(struct B32_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B32_extra_size) == 130, "");
_Static_assert(_Alignof(struct B32_extra_size) == 1, "");
_Static_assert(sizeof(B33) == 128, "");
_Static_assert(_Alignof(B33) == 128, "");
_Static_assert(sizeof(struct B33_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B33_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B33_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B33_extra_packed) == 1, "");
_Static_assert(sizeof(struct B33_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B33_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B33_extra_size) == 130, "");
_Static_assert(_Alignof(struct B33_extra_size) == 1, "");
_Static_assert(sizeof(B34) == 128, "");
_Static_assert(_Alignof(B34) == 128, "");
_Static_assert(sizeof(struct B34_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B34_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B34_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B34_extra_packed) == 1, "");
_Static_assert(sizeof(struct B34_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B34_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B34_extra_size) == 130, "");
_Static_assert(_Alignof(struct B34_extra_size) == 1, "");
_Static_assert(sizeof(B35) == 128, "");
_Static_assert(_Alignof(B35) == 128, "");
_Static_assert(sizeof(struct B35_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B35_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B35_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B35_extra_packed) == 1, "");
_Static_assert(sizeof(struct B35_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B35_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B35_extra_size) == 130, "");
_Static_assert(_Alignof(struct B35_extra_size) == 1, "");
_Static_assert(sizeof(B36) == 128, "");
_Static_assert(_Alignof(B36) == 128, "");
_Static_assert(sizeof(struct B36_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B36_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B36_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B36_extra_packed) == 1, "");
_Static_assert(sizeof(struct B36_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B36_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B36_extra_size) == 130, "");
_Static_assert(_Alignof(struct B36_extra_size) == 1, "");
_Static_assert(sizeof(B37) == 128, "");
_Static_assert(_Alignof(B37) == 128, "");
_Static_assert(sizeof(struct B37_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B37_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B37_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B37_extra_packed) == 1, "");
_Static_assert(sizeof(struct B37_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B37_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B37_extra_size) == 130, "");
_Static_assert(_Alignof(struct B37_extra_size) == 1, "");
_Static_assert(sizeof(B38) == 128, "");
_Static_assert(_Alignof(B38) == 128, "");
_Static_assert(sizeof(struct B38_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B38_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B38_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B38_extra_packed) == 1, "");
_Static_assert(sizeof(struct B38_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B38_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B38_extra_size) == 130, "");
_Static_assert(_Alignof(struct B38_extra_size) == 1, "");
_Static_assert(sizeof(B39) == 128, "");
_Static_assert(_Alignof(B39) == 128, "");
_Static_assert(sizeof(struct B39_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B39_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B39_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B39_extra_packed) == 1, "");
_Static_assert(sizeof(struct B39_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B39_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B39_extra_size) == 130, "");
_Static_assert(_Alignof(struct B39_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0066_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
#ifdef MSVC
__declspec(align(128)) int x;
#else
int x __attribute__((aligned(128)));
#endif
} A1;
A1 var1;
struct A1_extra_alignment {
char a;
A1 b;
};
struct A1_extra_alignment var2;
#pragma pack(1)
struct A1_extra_packed {
#ifdef MSVC
char a[sizeof(A1)];
#else
A1 a;
#endif
};
#pragma pack()
struct A1_extra_required_alignment {
char a;
struct A1_extra_packed b;
};
struct A1_extra_required_alignment var3;
struct A1_extra_size {
char a[sizeof(A1)+1];
char b;
};
struct A1_extra_size var4;
typedef union {
#ifdef MSVC
__declspec(align(128)) int x;
#else
int x __attribute__((aligned(128)));
#endif
} A2;
A2 var5;
struct A2_extra_alignment {
char a;
A2 b;
};
struct A2_extra_alignment var6;
#pragma pack(1)
struct A2_extra_packed {
#ifdef MSVC
char a[sizeof(A2)];
#else
A2 a;
#endif
};
#pragma pack()
struct A2_extra_required_alignment {
char a;
struct A2_extra_packed b;
};
struct A2_extra_required_alignment var7;
struct A2_extra_size {
char a[sizeof(A2)+1];
char b;
};
struct A2_extra_size var8;
#ifdef MSVC
__declspec(align(128)) typedef int B;
#else
typedef int B __attribute__((aligned(128)));
#endif
B var9;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var10;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var11;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var12;
typedef struct {
B x;
} C1;
C1 var13;
struct C1_extra_alignment {
char a;
C1 b;
};
struct C1_extra_alignment var14;
#pragma pack(1)
struct C1_extra_packed {
#ifdef MSVC
char a[sizeof(C1)];
#else
C1 a;
#endif
};
#pragma pack()
struct C1_extra_required_alignment {
char a;
struct C1_extra_packed b;
};
struct C1_extra_required_alignment var15;
struct C1_extra_size {
char a[sizeof(C1)+1];
char b;
};
struct C1_extra_size var16;
typedef union {
B x;
} C2;
C2 var17;
struct C2_extra_alignment {
char a;
C2 b;
};
struct C2_extra_alignment var18;
#pragma pack(1)
struct C2_extra_packed {
#ifdef MSVC
char a[sizeof(C2)];
#else
C2 a;
#endif
};
#pragma pack()
struct C2_extra_required_alignment {
char a;
struct C2_extra_packed b;
};
struct C2_extra_required_alignment var19;
struct C2_extra_size {
char a[sizeof(C2)+1];
char b;
};
struct C2_extra_size var20;
typedef struct {
#ifdef MSVC
__declspec(align(256)) B x;
#else
B x __attribute__((aligned(256)));
#endif
} D1;
D1 var21;
struct D1_extra_alignment {
char a;
D1 b;
};
struct D1_extra_alignment var22;
#pragma pack(1)
struct D1_extra_packed {
#ifdef MSVC
char a[sizeof(D1)];
#else
D1 a;
#endif
};
#pragma pack()
struct D1_extra_required_alignment {
char a;
struct D1_extra_packed b;
};
struct D1_extra_required_alignment var23;
struct D1_extra_size {
char a[sizeof(D1)+1];
char b;
};
struct D1_extra_size var24;
typedef union {
#ifdef MSVC
__declspec(align(256)) B x;
#else
B x __attribute__((aligned(256)));
#endif
} D2;
D2 var25;
struct D2_extra_alignment {
char a;
D2 b;
};
struct D2_extra_alignment var26;
#pragma pack(1)
struct D2_extra_packed {
#ifdef MSVC
char a[sizeof(D2)];
#else
D2 a;
#endif
};
#pragma pack()
struct D2_extra_required_alignment {
char a;
struct D2_extra_packed b;
};
struct D2_extra_required_alignment var27;
struct D2_extra_size {
char a[sizeof(D2)+1];
char b;
};
struct D2_extra_size var28;
#ifdef MSVC
__declspec(align(256)) typedef struct {
#else
typedef struct {
#endif
B x;
#ifdef MSVC
} E1;
#else
} __attribute__((aligned(256))) E1;
#endif
E1 var29;
struct E1_extra_alignment {
char a;
E1 b;
};
struct E1_extra_alignment var30;
#pragma pack(1)
struct E1_extra_packed {
#ifdef MSVC
char a[sizeof(E1)];
#else
E1 a;
#endif
};
#pragma pack()
struct E1_extra_required_alignment {
char a;
struct E1_extra_packed b;
};
struct E1_extra_required_alignment var31;
struct E1_extra_size {
char a[sizeof(E1)+1];
char b;
};
struct E1_extra_size var32;
#ifdef MSVC
__declspec(align(256)) typedef union {
#else
typedef union {
#endif
B x;
#ifdef MSVC
} E2;
#else
} __attribute__((aligned(256))) E2;
#endif
E2 var33;
struct E2_extra_alignment {
char a;
E2 b;
};
struct E2_extra_alignment var34;
#pragma pack(1)
struct E2_extra_packed {
#ifdef MSVC
char a[sizeof(E2)];
#else
E2 a;
#endif
};
#pragma pack()
struct E2_extra_required_alignment {
char a;
struct E2_extra_packed b;
};
struct E2_extra_required_alignment var35;
struct E2_extra_size {
char a[sizeof(E2)+1];
char b;
};
struct E2_extra_size var36;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A1) == 128, "");
_Static_assert(_Alignof(A1) == 128, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A1_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 130, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 128, "");
_Static_assert(_Alignof(A2) == 128, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A2_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 130, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C1) == 128, "");
_Static_assert(_Alignof(C1) == 128, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C1_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 130, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 128, "");
_Static_assert(_Alignof(C2) == 128, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C2_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 130, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
_Static_assert(sizeof(D1) == 256, "");
_Static_assert(_Alignof(D1) == 256, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 256, "");
_Static_assert(sizeof(struct D1_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 258, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
_Static_assert(sizeof(D2) == 256, "");
_Static_assert(_Alignof(D2) == 256, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 256, "");
_Static_assert(sizeof(struct D2_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 258, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E1) == 256, "");
_Static_assert(_Alignof(E1) == 256, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 256, "");
_Static_assert(sizeof(struct E1_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 258, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 256, "");
_Static_assert(_Alignof(E2) == 256, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 256, "");
_Static_assert(sizeof(struct E2_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 258, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A1) == 128, "");
_Static_assert(_Alignof(A1) == 128, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A1_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 130, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 128, "");
_Static_assert(_Alignof(A2) == 128, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A2_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 130, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C1) == 128, "");
_Static_assert(_Alignof(C1) == 128, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C1_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 130, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 128, "");
_Static_assert(_Alignof(C2) == 128, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C2_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 130, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
_Static_assert(sizeof(D1) == 256, "");
_Static_assert(_Alignof(D1) == 256, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 256, "");
_Static_assert(sizeof(struct D1_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 258, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
_Static_assert(sizeof(D2) == 256, "");
_Static_assert(_Alignof(D2) == 256, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 256, "");
_Static_assert(sizeof(struct D2_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 258, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E1) == 256, "");
_Static_assert(_Alignof(E1) == 256, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 256, "");
_Static_assert(sizeof(struct E1_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 258, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 256, "");
_Static_assert(_Alignof(E2) == 256, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 256, "");
_Static_assert(sizeof(struct E2_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 258, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A1) == 128, "");
_Static_assert(_Alignof(A1) == 128, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A1_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 130, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 128, "");
_Static_assert(_Alignof(A2) == 128, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A2_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 130, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C1) == 128, "");
_Static_assert(_Alignof(C1) == 128, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C1_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 130, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 128, "");
_Static_assert(_Alignof(C2) == 128, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C2_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 130, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
_Static_assert(sizeof(D1) == 256, "");
_Static_assert(_Alignof(D1) == 256, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 256, "");
_Static_assert(sizeof(struct D1_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 258, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
_Static_assert(sizeof(D2) == 256, "");
_Static_assert(_Alignof(D2) == 256, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 256, "");
_Static_assert(sizeof(struct D2_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 258, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E1) == 256, "");
_Static_assert(_Alignof(E1) == 256, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 256, "");
_Static_assert(sizeof(struct E1_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 258, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 256, "");
_Static_assert(_Alignof(E2) == 256, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 256, "");
_Static_assert(sizeof(struct E2_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 258, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
// MAPPING|FOUR|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A1) == 128, "");
_Static_assert(_Alignof(A1) == 128, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A1_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 130, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 128, "");
_Static_assert(_Alignof(A2) == 128, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A2_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 130, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C1) == 128, "");
_Static_assert(_Alignof(C1) == 128, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C1_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 130, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 128, "");
_Static_assert(_Alignof(C2) == 128, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C2_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 130, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
_Static_assert(sizeof(D1) == 256, "");
_Static_assert(_Alignof(D1) == 256, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 256, "");
_Static_assert(sizeof(struct D1_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 258, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
_Static_assert(sizeof(D2) == 256, "");
_Static_assert(_Alignof(D2) == 256, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 256, "");
_Static_assert(sizeof(struct D2_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 258, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E1) == 256, "");
_Static_assert(_Alignof(E1) == 256, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 256, "");
_Static_assert(sizeof(struct E1_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 258, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 256, "");
_Static_assert(_Alignof(E2) == 256, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 512, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 256, "");
_Static_assert(sizeof(struct E2_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 258, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0008_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef int unnamed_type_1[3];
unnamed_type_1 var2;
struct unnamed_type_1_extra_alignment {
char a;
unnamed_type_1 b;
};
struct unnamed_type_1_extra_alignment var3;
#pragma pack(1)
struct unnamed_type_1_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_1)];
#else
unnamed_type_1 a;
#endif
};
#pragma pack()
struct unnamed_type_1_extra_required_alignment {
char a;
struct unnamed_type_1_extra_packed b;
};
struct unnamed_type_1_extra_required_alignment var4;
struct unnamed_type_1_extra_size {
char a[sizeof(unnamed_type_1)+1];
char b;
};
struct unnamed_type_1_extra_size var5;
#ifdef MSVC
__declspec(align(8)) typedef unnamed_type_1 Int;
#else
typedef unnamed_type_1 Int __attribute__((aligned(8)));
#endif
Int var6;
struct Int_extra_alignment {
char a;
Int b;
};
struct Int_extra_alignment var7;
#pragma pack(1)
struct Int_extra_packed {
#ifdef MSVC
char a[sizeof(Int)];
#else
Int a;
#endif
};
#pragma pack()
struct Int_extra_required_alignment {
char a;
struct Int_extra_packed b;
};
struct Int_extra_required_alignment var8;
struct Int_extra_size {
char a[sizeof(Int)+1];
char b;
};
struct Int_extra_size var9;
typedef Int unnamed_type_10[3];
unnamed_type_10 var11;
struct unnamed_type_10_extra_alignment {
char a;
unnamed_type_10 b;
};
struct unnamed_type_10_extra_alignment var12;
#pragma pack(1)
struct unnamed_type_10_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_10)];
#else
unnamed_type_10 a;
#endif
};
#pragma pack()
struct unnamed_type_10_extra_required_alignment {
char a;
struct unnamed_type_10_extra_packed b;
};
struct unnamed_type_10_extra_required_alignment var13;
struct unnamed_type_10_extra_size {
char a[sizeof(unnamed_type_10)+1];
char b;
};
struct unnamed_type_10_extra_size var14;
typedef unnamed_type_10 Y;
Y var15;
struct Y_extra_alignment {
char a;
Y b;
};
struct Y_extra_alignment var16;
#pragma pack(1)
struct Y_extra_packed {
#ifdef MSVC
char a[sizeof(Y)];
#else
Y a;
#endif
};
#pragma pack()
struct Y_extra_required_alignment {
char a;
struct Y_extra_packed b;
};
struct Y_extra_required_alignment var17;
struct Y_extra_size {
char a[sizeof(Y)+1];
char b;
};
struct Y_extra_size var18;
typedef struct {
Y y;
int i;
} Z;
Z var19;
struct Z_extra_alignment {
char a;
Z b;
};
struct Z_extra_alignment var20;
#pragma pack(1)
struct Z_extra_packed {
#ifdef MSVC
char a[sizeof(Z)];
#else
Z a;
#endif
};
#pragma pack()
struct Z_extra_required_alignment {
char a;
struct Z_extra_packed b;
};
struct Z_extra_required_alignment var21;
struct Z_extra_size {
char a[sizeof(Z)+1];
char b;
};
struct Z_extra_size var22;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(Int) == 12, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 12, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 14, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 40, "");
_Static_assert(_Alignof(Y) == 8, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y_extra_packed) == 40, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 41, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 42, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
_Static_assert(sizeof(Z) == 48, "");
_Static_assert(_Alignof(Z) == 8, "");
_Static_assert(sizeof(struct Z_extra_alignment) == 56, "");
_Static_assert(_Alignof(struct Z_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Z_extra_packed) == 48, "");
_Static_assert(_Alignof(struct Z_extra_packed) == 1, "");
_Static_assert(sizeof(struct Z_extra_required_alignment) == 49, "");
_Static_assert(_Alignof(struct Z_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Z_extra_size) == 50, "");
_Static_assert(_Alignof(struct Z_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Z,i) == 320, "");
#endif
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(Int) == 12, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 12, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 14, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 36, "");
_Static_assert(_Alignof(Y) == 8, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y_extra_packed) == 36, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 37, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 38, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
_Static_assert(sizeof(Z) == 40, "");
_Static_assert(_Alignof(Z) == 8, "");
_Static_assert(sizeof(struct Z_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct Z_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Z_extra_packed) == 40, "");
_Static_assert(_Alignof(struct Z_extra_packed) == 1, "");
_Static_assert(sizeof(struct Z_extra_required_alignment) == 41, "");
_Static_assert(_Alignof(struct Z_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Z_extra_size) == 42, "");
_Static_assert(_Alignof(struct Z_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Z,i) == 288, "");
#endif
// MAPPING|THREE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(Int) == 6, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 6, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 8, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 24, "");
_Static_assert(_Alignof(Y) == 8, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y_extra_packed) == 24, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 26, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
_Static_assert(sizeof(Z) == 32, "");
_Static_assert(_Alignof(Z) == 8, "");
_Static_assert(sizeof(struct Z_extra_alignment) == 40, "");
_Static_assert(_Alignof(struct Z_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Z_extra_packed) == 32, "");
_Static_assert(_Alignof(struct Z_extra_packed) == 1, "");
_Static_assert(sizeof(struct Z_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct Z_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Z_extra_size) == 34, "");
_Static_assert(_Alignof(struct Z_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Z,i) == 192, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0083_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c:1;
char d:1 __attribute__((aligned(2)));
char e:1;
} A000;
A000 var1;
struct A000_extra_alignment {
char a;
A000 b;
};
struct A000_extra_alignment var2;
#pragma pack(1)
struct A000_extra_packed {
A000 a;
};
#pragma pack()
struct A000_extra_required_alignment {
char a;
struct A000_extra_packed b;
};
struct A000_extra_required_alignment var3;
struct A000_extra_size {
char a[sizeof(A000)+1];
char b;
};
struct A000_extra_size var4;
#pragma pack(1)
typedef struct {
char c:1;
char d:1 __attribute__((aligned(2)));
char e:1;
} A001;
A001 var5;
#pragma pack()
struct A001_extra_alignment {
char a;
A001 b;
};
struct A001_extra_alignment var6;
#pragma pack(1)
struct A001_extra_packed {
A001 a;
};
#pragma pack()
struct A001_extra_required_alignment {
char a;
struct A001_extra_packed b;
};
struct A001_extra_required_alignment var7;
struct A001_extra_size {
char a[sizeof(A001)+1];
char b;
};
struct A001_extra_size var8;
#pragma pack(2)
typedef struct {
char c:1;
char d:1 __attribute__((aligned(4)));
char e:1;
} A002;
A002 var9;
#pragma pack()
struct A002_extra_alignment {
char a;
A002 b;
};
struct A002_extra_alignment var10;
#pragma pack(1)
struct A002_extra_packed {
A002 a;
};
#pragma pack()
struct A002_extra_required_alignment {
char a;
struct A002_extra_packed b;
};
struct A002_extra_required_alignment var11;
struct A002_extra_size {
char a[sizeof(A002)+1];
char b;
};
struct A002_extra_size var12;
#pragma pack(4)
typedef struct {
char c:1;
char d:1 __attribute__((aligned(4)));
char e:1;
} A003;
A003 var13;
#pragma pack()
struct A003_extra_alignment {
char a;
A003 b;
};
struct A003_extra_alignment var14;
#pragma pack(1)
struct A003_extra_packed {
A003 a;
};
#pragma pack()
struct A003_extra_required_alignment {
char a;
struct A003_extra_packed b;
};
struct A003_extra_required_alignment var15;
struct A003_extra_size {
char a[sizeof(A003)+1];
char b;
};
struct A003_extra_size var16;
#pragma pack(8)
typedef struct {
char c:1;
char d:1 __attribute__((aligned(4)));
char e:1;
} A004;
A004 var17;
#pragma pack()
struct A004_extra_alignment {
char a;
A004 b;
};
struct A004_extra_alignment var18;
#pragma pack(1)
struct A004_extra_packed {
A004 a;
};
#pragma pack()
struct A004_extra_required_alignment {
char a;
struct A004_extra_packed b;
};
struct A004_extra_required_alignment var19;
struct A004_extra_size {
char a[sizeof(A004)+1];
char b;
};
struct A004_extra_size var20;
typedef struct {
char c:1;
char d:1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} A005;
A005 var21;
struct A005_extra_alignment {
char a;
A005 b;
};
struct A005_extra_alignment var22;
#pragma pack(1)
struct A005_extra_packed {
A005 a;
};
#pragma pack()
struct A005_extra_required_alignment {
char a;
struct A005_extra_packed b;
};
struct A005_extra_required_alignment var23;
struct A005_extra_size {
char a[sizeof(A005)+1];
char b;
};
struct A005_extra_size var24;
#pragma pack(1)
typedef struct {
char c:1;
char d:1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} A006;
A006 var25;
#pragma pack()
struct A006_extra_alignment {
char a;
A006 b;
};
struct A006_extra_alignment var26;
#pragma pack(1)
struct A006_extra_packed {
A006 a;
};
#pragma pack()
struct A006_extra_required_alignment {
char a;
struct A006_extra_packed b;
};
struct A006_extra_required_alignment var27;
struct A006_extra_size {
char a[sizeof(A006)+1];
char b;
};
struct A006_extra_size var28;
#pragma pack(2)
typedef struct {
char c:1;
char d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A007;
A007 var29;
#pragma pack()
struct A007_extra_alignment {
char a;
A007 b;
};
struct A007_extra_alignment var30;
#pragma pack(1)
struct A007_extra_packed {
A007 a;
};
#pragma pack()
struct A007_extra_required_alignment {
char a;
struct A007_extra_packed b;
};
struct A007_extra_required_alignment var31;
struct A007_extra_size {
char a[sizeof(A007)+1];
char b;
};
struct A007_extra_size var32;
#pragma pack(4)
typedef struct {
char c:1;
char d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A008;
A008 var33;
#pragma pack()
struct A008_extra_alignment {
char a;
A008 b;
};
struct A008_extra_alignment var34;
#pragma pack(1)
struct A008_extra_packed {
A008 a;
};
#pragma pack()
struct A008_extra_required_alignment {
char a;
struct A008_extra_packed b;
};
struct A008_extra_required_alignment var35;
struct A008_extra_size {
char a[sizeof(A008)+1];
char b;
};
struct A008_extra_size var36;
#pragma pack(8)
typedef struct {
char c:1;
char d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A009;
A009 var37;
#pragma pack()
struct A009_extra_alignment {
char a;
A009 b;
};
struct A009_extra_alignment var38;
#pragma pack(1)
struct A009_extra_packed {
A009 a;
};
#pragma pack()
struct A009_extra_required_alignment {
char a;
struct A009_extra_packed b;
};
struct A009_extra_required_alignment var39;
struct A009_extra_size {
char a[sizeof(A009)+1];
char b;
};
struct A009_extra_size var40;
typedef struct {
char c:1;
char d:8 __attribute__((aligned(2)));
char e:1;
} A010;
A010 var41;
struct A010_extra_alignment {
char a;
A010 b;
};
struct A010_extra_alignment var42;
#pragma pack(1)
struct A010_extra_packed {
A010 a;
};
#pragma pack()
struct A010_extra_required_alignment {
char a;
struct A010_extra_packed b;
};
struct A010_extra_required_alignment var43;
struct A010_extra_size {
char a[sizeof(A010)+1];
char b;
};
struct A010_extra_size var44;
#pragma pack(1)
typedef struct {
char c:1;
char d:8 __attribute__((aligned(2)));
char e:1;
} A011;
A011 var45;
#pragma pack()
struct A011_extra_alignment {
char a;
A011 b;
};
struct A011_extra_alignment var46;
#pragma pack(1)
struct A011_extra_packed {
A011 a;
};
#pragma pack()
struct A011_extra_required_alignment {
char a;
struct A011_extra_packed b;
};
struct A011_extra_required_alignment var47;
struct A011_extra_size {
char a[sizeof(A011)+1];
char b;
};
struct A011_extra_size var48;
#pragma pack(2)
typedef struct {
char c:1;
char d:8 __attribute__((aligned(4)));
char e:1;
} A012;
A012 var49;
#pragma pack()
struct A012_extra_alignment {
char a;
A012 b;
};
struct A012_extra_alignment var50;
#pragma pack(1)
struct A012_extra_packed {
A012 a;
};
#pragma pack()
struct A012_extra_required_alignment {
char a;
struct A012_extra_packed b;
};
struct A012_extra_required_alignment var51;
struct A012_extra_size {
char a[sizeof(A012)+1];
char b;
};
struct A012_extra_size var52;
#pragma pack(4)
typedef struct {
char c:1;
char d:8 __attribute__((aligned(4)));
char e:1;
} A013;
A013 var53;
#pragma pack()
struct A013_extra_alignment {
char a;
A013 b;
};
struct A013_extra_alignment var54;
#pragma pack(1)
struct A013_extra_packed {
A013 a;
};
#pragma pack()
struct A013_extra_required_alignment {
char a;
struct A013_extra_packed b;
};
struct A013_extra_required_alignment var55;
struct A013_extra_size {
char a[sizeof(A013)+1];
char b;
};
struct A013_extra_size var56;
#pragma pack(8)
typedef struct {
char c:1;
char d:8 __attribute__((aligned(4)));
char e:1;
} A014;
A014 var57;
#pragma pack()
struct A014_extra_alignment {
char a;
A014 b;
};
struct A014_extra_alignment var58;
#pragma pack(1)
struct A014_extra_packed {
A014 a;
};
#pragma pack()
struct A014_extra_required_alignment {
char a;
struct A014_extra_packed b;
};
struct A014_extra_required_alignment var59;
struct A014_extra_size {
char a[sizeof(A014)+1];
char b;
};
struct A014_extra_size var60;
typedef struct {
char c:1;
char d:8 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} A015;
A015 var61;
struct A015_extra_alignment {
char a;
A015 b;
};
struct A015_extra_alignment var62;
#pragma pack(1)
struct A015_extra_packed {
A015 a;
};
#pragma pack()
struct A015_extra_required_alignment {
char a;
struct A015_extra_packed b;
};
struct A015_extra_required_alignment var63;
struct A015_extra_size {
char a[sizeof(A015)+1];
char b;
};
struct A015_extra_size var64;
#pragma pack(1)
typedef struct {
char c:1;
char d:8 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} A016;
A016 var65;
#pragma pack()
struct A016_extra_alignment {
char a;
A016 b;
};
struct A016_extra_alignment var66;
#pragma pack(1)
struct A016_extra_packed {
A016 a;
};
#pragma pack()
struct A016_extra_required_alignment {
char a;
struct A016_extra_packed b;
};
struct A016_extra_required_alignment var67;
struct A016_extra_size {
char a[sizeof(A016)+1];
char b;
};
struct A016_extra_size var68;
#pragma pack(2)
typedef struct {
char c:1;
char d:8 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A017;
A017 var69;
#pragma pack()
struct A017_extra_alignment {
char a;
A017 b;
};
struct A017_extra_alignment var70;
#pragma pack(1)
struct A017_extra_packed {
A017 a;
};
#pragma pack()
struct A017_extra_required_alignment {
char a;
struct A017_extra_packed b;
};
struct A017_extra_required_alignment var71;
struct A017_extra_size {
char a[sizeof(A017)+1];
char b;
};
struct A017_extra_size var72;
#pragma pack(4)
typedef struct {
char c:1;
char d:8 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A018;
A018 var73;
#pragma pack()
struct A018_extra_alignment {
char a;
A018 b;
};
struct A018_extra_alignment var74;
#pragma pack(1)
struct A018_extra_packed {
A018 a;
};
#pragma pack()
struct A018_extra_required_alignment {
char a;
struct A018_extra_packed b;
};
struct A018_extra_required_alignment var75;
struct A018_extra_size {
char a[sizeof(A018)+1];
char b;
};
struct A018_extra_size var76;
#pragma pack(8)
typedef struct {
char c:1;
char d:8 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A019;
A019 var77;
#pragma pack()
struct A019_extra_alignment {
char a;
A019 b;
};
struct A019_extra_alignment var78;
#pragma pack(1)
struct A019_extra_packed {
A019 a;
};
#pragma pack()
struct A019_extra_required_alignment {
char a;
struct A019_extra_packed b;
};
struct A019_extra_required_alignment var79;
struct A019_extra_size {
char a[sizeof(A019)+1];
char b;
};
struct A019_extra_size var80;
typedef struct {
char c:2;
long d:1 __attribute__((aligned(2)));
char e:1;
} A100;
A100 var81;
struct A100_extra_alignment {
char a;
A100 b;
};
struct A100_extra_alignment var82;
#pragma pack(1)
struct A100_extra_packed {
A100 a;
};
#pragma pack()
struct A100_extra_required_alignment {
char a;
struct A100_extra_packed b;
};
struct A100_extra_required_alignment var83;
struct A100_extra_size {
char a[sizeof(A100)+1];
char b;
};
struct A100_extra_size var84;
#pragma pack(1)
typedef struct {
char c:2;
long d:1 __attribute__((aligned(2)));
char e:1;
} A101;
A101 var85;
#pragma pack()
struct A101_extra_alignment {
char a;
A101 b;
};
struct A101_extra_alignment var86;
#pragma pack(1)
struct A101_extra_packed {
A101 a;
};
#pragma pack()
struct A101_extra_required_alignment {
char a;
struct A101_extra_packed b;
};
struct A101_extra_required_alignment var87;
struct A101_extra_size {
char a[sizeof(A101)+1];
char b;
};
struct A101_extra_size var88;
#pragma pack(2)
typedef struct {
char c:2;
long d:1 __attribute__((aligned(4)));
char e:1;
} A102;
A102 var89;
#pragma pack()
struct A102_extra_alignment {
char a;
A102 b;
};
struct A102_extra_alignment var90;
#pragma pack(1)
struct A102_extra_packed {
A102 a;
};
#pragma pack()
struct A102_extra_required_alignment {
char a;
struct A102_extra_packed b;
};
struct A102_extra_required_alignment var91;
struct A102_extra_size {
char a[sizeof(A102)+1];
char b;
};
struct A102_extra_size var92;
#pragma pack(4)
typedef struct {
char c:2;
long d:1 __attribute__((aligned(4)));
char e:1;
} A103;
A103 var93;
#pragma pack()
struct A103_extra_alignment {
char a;
A103 b;
};
struct A103_extra_alignment var94;
#pragma pack(1)
struct A103_extra_packed {
A103 a;
};
#pragma pack()
struct A103_extra_required_alignment {
char a;
struct A103_extra_packed b;
};
struct A103_extra_required_alignment var95;
struct A103_extra_size {
char a[sizeof(A103)+1];
char b;
};
struct A103_extra_size var96;
#pragma pack(8)
typedef struct {
char c:2;
long d:1 __attribute__((aligned(4)));
char e:1;
} A104;
A104 var97;
#pragma pack()
struct A104_extra_alignment {
char a;
A104 b;
};
struct A104_extra_alignment var98;
#pragma pack(1)
struct A104_extra_packed {
A104 a;
};
#pragma pack()
struct A104_extra_required_alignment {
char a;
struct A104_extra_packed b;
};
struct A104_extra_required_alignment var99;
struct A104_extra_size {
char a[sizeof(A104)+1];
char b;
};
struct A104_extra_size var100;
typedef struct {
char c:2;
long d:1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} A105;
A105 var101;
struct A105_extra_alignment {
char a;
A105 b;
};
struct A105_extra_alignment var102;
#pragma pack(1)
struct A105_extra_packed {
A105 a;
};
#pragma pack()
struct A105_extra_required_alignment {
char a;
struct A105_extra_packed b;
};
struct A105_extra_required_alignment var103;
struct A105_extra_size {
char a[sizeof(A105)+1];
char b;
};
struct A105_extra_size var104;
#pragma pack(1)
typedef struct {
char c:2;
long d:1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} A106;
A106 var105;
#pragma pack()
struct A106_extra_alignment {
char a;
A106 b;
};
struct A106_extra_alignment var106;
#pragma pack(1)
struct A106_extra_packed {
A106 a;
};
#pragma pack()
struct A106_extra_required_alignment {
char a;
struct A106_extra_packed b;
};
struct A106_extra_required_alignment var107;
struct A106_extra_size {
char a[sizeof(A106)+1];
char b;
};
struct A106_extra_size var108;
#pragma pack(2)
typedef struct {
char c:2;
long d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A107;
A107 var109;
#pragma pack()
struct A107_extra_alignment {
char a;
A107 b;
};
struct A107_extra_alignment var110;
#pragma pack(1)
struct A107_extra_packed {
A107 a;
};
#pragma pack()
struct A107_extra_required_alignment {
char a;
struct A107_extra_packed b;
};
struct A107_extra_required_alignment var111;
struct A107_extra_size {
char a[sizeof(A107)+1];
char b;
};
struct A107_extra_size var112;
#pragma pack(4)
typedef struct {
char c:2;
long d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A108;
A108 var113;
#pragma pack()
struct A108_extra_alignment {
char a;
A108 b;
};
struct A108_extra_alignment var114;
#pragma pack(1)
struct A108_extra_packed {
A108 a;
};
#pragma pack()
struct A108_extra_required_alignment {
char a;
struct A108_extra_packed b;
};
struct A108_extra_required_alignment var115;
struct A108_extra_size {
char a[sizeof(A108)+1];
char b;
};
struct A108_extra_size var116;
#pragma pack(8)
typedef struct {
char c:2;
long d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A109;
A109 var117;
#pragma pack()
struct A109_extra_alignment {
char a;
A109 b;
};
struct A109_extra_alignment var118;
#pragma pack(1)
struct A109_extra_packed {
A109 a;
};
#pragma pack()
struct A109_extra_required_alignment {
char a;
struct A109_extra_packed b;
};
struct A109_extra_required_alignment var119;
struct A109_extra_size {
char a[sizeof(A109)+1];
char b;
};
struct A109_extra_size var120;
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(2)));
char e:1;
} A110;
A110 var121;
struct A110_extra_alignment {
char a;
A110 b;
};
struct A110_extra_alignment var122;
#pragma pack(1)
struct A110_extra_packed {
A110 a;
};
#pragma pack()
struct A110_extra_required_alignment {
char a;
struct A110_extra_packed b;
};
struct A110_extra_required_alignment var123;
struct A110_extra_size {
char a[sizeof(A110)+1];
char b;
};
struct A110_extra_size var124;
#pragma pack(1)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(2)));
char e:1;
} A111;
A111 var125;
#pragma pack()
struct A111_extra_alignment {
char a;
A111 b;
};
struct A111_extra_alignment var126;
#pragma pack(1)
struct A111_extra_packed {
A111 a;
};
#pragma pack()
struct A111_extra_required_alignment {
char a;
struct A111_extra_packed b;
};
struct A111_extra_required_alignment var127;
struct A111_extra_size {
char a[sizeof(A111)+1];
char b;
};
struct A111_extra_size var128;
#pragma pack(2)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4)));
char e:1;
} A112;
A112 var129;
#pragma pack()
struct A112_extra_alignment {
char a;
A112 b;
};
struct A112_extra_alignment var130;
#pragma pack(1)
struct A112_extra_packed {
A112 a;
};
#pragma pack()
struct A112_extra_required_alignment {
char a;
struct A112_extra_packed b;
};
struct A112_extra_required_alignment var131;
struct A112_extra_size {
char a[sizeof(A112)+1];
char b;
};
struct A112_extra_size var132;
#pragma pack(4)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4)));
char e:1;
} A113;
A113 var133;
#pragma pack()
struct A113_extra_alignment {
char a;
A113 b;
};
struct A113_extra_alignment var134;
#pragma pack(1)
struct A113_extra_packed {
A113 a;
};
#pragma pack()
struct A113_extra_required_alignment {
char a;
struct A113_extra_packed b;
};
struct A113_extra_required_alignment var135;
struct A113_extra_size {
char a[sizeof(A113)+1];
char b;
};
struct A113_extra_size var136;
#pragma pack(8)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4)));
char e:1;
} A114;
A114 var137;
#pragma pack()
struct A114_extra_alignment {
char a;
A114 b;
};
struct A114_extra_alignment var138;
#pragma pack(1)
struct A114_extra_packed {
A114 a;
};
#pragma pack()
struct A114_extra_required_alignment {
char a;
struct A114_extra_packed b;
};
struct A114_extra_required_alignment var139;
struct A114_extra_size {
char a[sizeof(A114)+1];
char b;
};
struct A114_extra_size var140;
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} A115;
A115 var141;
struct A115_extra_alignment {
char a;
A115 b;
};
struct A115_extra_alignment var142;
#pragma pack(1)
struct A115_extra_packed {
A115 a;
};
#pragma pack()
struct A115_extra_required_alignment {
char a;
struct A115_extra_packed b;
};
struct A115_extra_required_alignment var143;
struct A115_extra_size {
char a[sizeof(A115)+1];
char b;
};
struct A115_extra_size var144;
#pragma pack(1)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} A116;
A116 var145;
#pragma pack()
struct A116_extra_alignment {
char a;
A116 b;
};
struct A116_extra_alignment var146;
#pragma pack(1)
struct A116_extra_packed {
A116 a;
};
#pragma pack()
struct A116_extra_required_alignment {
char a;
struct A116_extra_packed b;
};
struct A116_extra_required_alignment var147;
struct A116_extra_size {
char a[sizeof(A116)+1];
char b;
};
struct A116_extra_size var148;
#pragma pack(2)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A117;
A117 var149;
#pragma pack()
struct A117_extra_alignment {
char a;
A117 b;
};
struct A117_extra_alignment var150;
#pragma pack(1)
struct A117_extra_packed {
A117 a;
};
#pragma pack()
struct A117_extra_required_alignment {
char a;
struct A117_extra_packed b;
};
struct A117_extra_required_alignment var151;
struct A117_extra_size {
char a[sizeof(A117)+1];
char b;
};
struct A117_extra_size var152;
#pragma pack(4)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A118;
A118 var153;
#pragma pack()
struct A118_extra_alignment {
char a;
A118 b;
};
struct A118_extra_alignment var154;
#pragma pack(1)
struct A118_extra_packed {
A118 a;
};
#pragma pack()
struct A118_extra_required_alignment {
char a;
struct A118_extra_packed b;
};
struct A118_extra_required_alignment var155;
struct A118_extra_size {
char a[sizeof(A118)+1];
char b;
};
struct A118_extra_size var156;
#pragma pack(8)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A119;
A119 var157;
#pragma pack()
struct A119_extra_alignment {
char a;
A119 b;
};
struct A119_extra_alignment var158;
#pragma pack(1)
struct A119_extra_packed {
A119 a;
};
#pragma pack()
struct A119_extra_required_alignment {
char a;
struct A119_extra_packed b;
};
struct A119_extra_required_alignment var159;
struct A119_extra_size {
char a[sizeof(A119)+1];
char b;
};
struct A119_extra_size var160;
typedef struct {
char c:1;
char d:1;
char e:1;
} A200;
A200 var161;
struct A200_extra_alignment {
char a;
A200 b;
};
struct A200_extra_alignment var162;
#pragma pack(1)
struct A200_extra_packed {
A200 a;
};
#pragma pack()
struct A200_extra_required_alignment {
char a;
struct A200_extra_packed b;
};
struct A200_extra_required_alignment var163;
struct A200_extra_size {
char a[sizeof(A200)+1];
char b;
};
struct A200_extra_size var164;
#pragma pack(1)
typedef struct {
char c:1;
char d:1;
char e:1;
} A201;
A201 var165;
#pragma pack()
struct A201_extra_alignment {
char a;
A201 b;
};
struct A201_extra_alignment var166;
#pragma pack(1)
struct A201_extra_packed {
A201 a;
};
#pragma pack()
struct A201_extra_required_alignment {
char a;
struct A201_extra_packed b;
};
struct A201_extra_required_alignment var167;
struct A201_extra_size {
char a[sizeof(A201)+1];
char b;
};
struct A201_extra_size var168;
#pragma pack(2)
typedef struct {
char c:1;
char d:1;
char e:1;
} A202;
A202 var169;
#pragma pack()
struct A202_extra_alignment {
char a;
A202 b;
};
struct A202_extra_alignment var170;
#pragma pack(1)
struct A202_extra_packed {
A202 a;
};
#pragma pack()
struct A202_extra_required_alignment {
char a;
struct A202_extra_packed b;
};
struct A202_extra_required_alignment var171;
struct A202_extra_size {
char a[sizeof(A202)+1];
char b;
};
struct A202_extra_size var172;
#pragma pack(4)
typedef struct {
char c:1;
char d:1;
char e:1;
} A203;
A203 var173;
#pragma pack()
struct A203_extra_alignment {
char a;
A203 b;
};
struct A203_extra_alignment var174;
#pragma pack(1)
struct A203_extra_packed {
A203 a;
};
#pragma pack()
struct A203_extra_required_alignment {
char a;
struct A203_extra_packed b;
};
struct A203_extra_required_alignment var175;
struct A203_extra_size {
char a[sizeof(A203)+1];
char b;
};
struct A203_extra_size var176;
#pragma pack(8)
typedef struct {
char c:1;
char d:1;
char e:1;
} A204;
A204 var177;
#pragma pack()
struct A204_extra_alignment {
char a;
A204 b;
};
struct A204_extra_alignment var178;
#pragma pack(1)
struct A204_extra_packed {
A204 a;
};
#pragma pack()
struct A204_extra_required_alignment {
char a;
struct A204_extra_packed b;
};
struct A204_extra_required_alignment var179;
struct A204_extra_size {
char a[sizeof(A204)+1];
char b;
};
struct A204_extra_size var180;
typedef struct {
char c:1;
char d:1 __attribute__((packed));
char e:1;
} A205;
A205 var181;
struct A205_extra_alignment {
char a;
A205 b;
};
struct A205_extra_alignment var182;
#pragma pack(1)
struct A205_extra_packed {
A205 a;
};
#pragma pack()
struct A205_extra_required_alignment {
char a;
struct A205_extra_packed b;
};
struct A205_extra_required_alignment var183;
struct A205_extra_size {
char a[sizeof(A205)+1];
char b;
};
struct A205_extra_size var184;
#pragma pack(1)
typedef struct {
char c:1;
char d:1 __attribute__((packed));
char e:1;
} A206;
A206 var185;
#pragma pack()
struct A206_extra_alignment {
char a;
A206 b;
};
struct A206_extra_alignment var186;
#pragma pack(1)
struct A206_extra_packed {
A206 a;
};
#pragma pack()
struct A206_extra_required_alignment {
char a;
struct A206_extra_packed b;
};
struct A206_extra_required_alignment var187;
struct A206_extra_size {
char a[sizeof(A206)+1];
char b;
};
struct A206_extra_size var188;
#pragma pack(2)
typedef struct {
char c:1;
char d:1 __attribute__((packed));
char e:1;
} A207;
A207 var189;
#pragma pack()
struct A207_extra_alignment {
char a;
A207 b;
};
struct A207_extra_alignment var190;
#pragma pack(1)
struct A207_extra_packed {
A207 a;
};
#pragma pack()
struct A207_extra_required_alignment {
char a;
struct A207_extra_packed b;
};
struct A207_extra_required_alignment var191;
struct A207_extra_size {
char a[sizeof(A207)+1];
char b;
};
struct A207_extra_size var192;
#pragma pack(4)
typedef struct {
char c:1;
char d:1 __attribute__((packed));
char e:1;
} A208;
A208 var193;
#pragma pack()
struct A208_extra_alignment {
char a;
A208 b;
};
struct A208_extra_alignment var194;
#pragma pack(1)
struct A208_extra_packed {
A208 a;
};
#pragma pack()
struct A208_extra_required_alignment {
char a;
struct A208_extra_packed b;
};
struct A208_extra_required_alignment var195;
struct A208_extra_size {
char a[sizeof(A208)+1];
char b;
};
struct A208_extra_size var196;
#pragma pack(8)
typedef struct {
char c:1;
char d:1 __attribute__((packed));
char e:1;
} A209;
A209 var197;
#pragma pack()
struct A209_extra_alignment {
char a;
A209 b;
};
struct A209_extra_alignment var198;
#pragma pack(1)
struct A209_extra_packed {
A209 a;
};
#pragma pack()
struct A209_extra_required_alignment {
char a;
struct A209_extra_packed b;
};
struct A209_extra_required_alignment var199;
struct A209_extra_size {
char a[sizeof(A209)+1];
char b;
};
struct A209_extra_size var200;
typedef struct {
char c:1;
char d:8;
char e:1;
} A210;
A210 var201;
struct A210_extra_alignment {
char a;
A210 b;
};
struct A210_extra_alignment var202;
#pragma pack(1)
struct A210_extra_packed {
A210 a;
};
#pragma pack()
struct A210_extra_required_alignment {
char a;
struct A210_extra_packed b;
};
struct A210_extra_required_alignment var203;
struct A210_extra_size {
char a[sizeof(A210)+1];
char b;
};
struct A210_extra_size var204;
#pragma pack(1)
typedef struct {
char c:1;
char d:8;
char e:1;
} A211;
A211 var205;
#pragma pack()
struct A211_extra_alignment {
char a;
A211 b;
};
struct A211_extra_alignment var206;
#pragma pack(1)
struct A211_extra_packed {
A211 a;
};
#pragma pack()
struct A211_extra_required_alignment {
char a;
struct A211_extra_packed b;
};
struct A211_extra_required_alignment var207;
struct A211_extra_size {
char a[sizeof(A211)+1];
char b;
};
struct A211_extra_size var208;
#pragma pack(2)
typedef struct {
char c:1;
char d:8;
char e:1;
} A212;
A212 var209;
#pragma pack()
struct A212_extra_alignment {
char a;
A212 b;
};
struct A212_extra_alignment var210;
#pragma pack(1)
struct A212_extra_packed {
A212 a;
};
#pragma pack()
struct A212_extra_required_alignment {
char a;
struct A212_extra_packed b;
};
struct A212_extra_required_alignment var211;
struct A212_extra_size {
char a[sizeof(A212)+1];
char b;
};
struct A212_extra_size var212;
#pragma pack(4)
typedef struct {
char c:1;
char d:8;
char e:1;
} A213;
A213 var213;
#pragma pack()
struct A213_extra_alignment {
char a;
A213 b;
};
struct A213_extra_alignment var214;
#pragma pack(1)
struct A213_extra_packed {
A213 a;
};
#pragma pack()
struct A213_extra_required_alignment {
char a;
struct A213_extra_packed b;
};
struct A213_extra_required_alignment var215;
struct A213_extra_size {
char a[sizeof(A213)+1];
char b;
};
struct A213_extra_size var216;
#pragma pack(8)
typedef struct {
char c:1;
char d:8;
char e:1;
} A214;
A214 var217;
#pragma pack()
struct A214_extra_alignment {
char a;
A214 b;
};
struct A214_extra_alignment var218;
#pragma pack(1)
struct A214_extra_packed {
A214 a;
};
#pragma pack()
struct A214_extra_required_alignment {
char a;
struct A214_extra_packed b;
};
struct A214_extra_required_alignment var219;
struct A214_extra_size {
char a[sizeof(A214)+1];
char b;
};
struct A214_extra_size var220;
typedef struct {
char c:1;
char d:8 __attribute__((packed));
char e:1;
} A215;
A215 var221;
struct A215_extra_alignment {
char a;
A215 b;
};
struct A215_extra_alignment var222;
#pragma pack(1)
struct A215_extra_packed {
A215 a;
};
#pragma pack()
struct A215_extra_required_alignment {
char a;
struct A215_extra_packed b;
};
struct A215_extra_required_alignment var223;
struct A215_extra_size {
char a[sizeof(A215)+1];
char b;
};
struct A215_extra_size var224;
#pragma pack(1)
typedef struct {
char c:1;
char d:8 __attribute__((packed));
char e:1;
} A216;
A216 var225;
#pragma pack()
struct A216_extra_alignment {
char a;
A216 b;
};
struct A216_extra_alignment var226;
#pragma pack(1)
struct A216_extra_packed {
A216 a;
};
#pragma pack()
struct A216_extra_required_alignment {
char a;
struct A216_extra_packed b;
};
struct A216_extra_required_alignment var227;
struct A216_extra_size {
char a[sizeof(A216)+1];
char b;
};
struct A216_extra_size var228;
#pragma pack(2)
typedef struct {
char c:1;
char d:8 __attribute__((packed));
char e:1;
} A217;
A217 var229;
#pragma pack()
struct A217_extra_alignment {
char a;
A217 b;
};
struct A217_extra_alignment var230;
#pragma pack(1)
struct A217_extra_packed {
A217 a;
};
#pragma pack()
struct A217_extra_required_alignment {
char a;
struct A217_extra_packed b;
};
struct A217_extra_required_alignment var231;
struct A217_extra_size {
char a[sizeof(A217)+1];
char b;
};
struct A217_extra_size var232;
#pragma pack(4)
typedef struct {
char c:1;
char d:8 __attribute__((packed));
char e:1;
} A218;
A218 var233;
#pragma pack()
struct A218_extra_alignment {
char a;
A218 b;
};
struct A218_extra_alignment var234;
#pragma pack(1)
struct A218_extra_packed {
A218 a;
};
#pragma pack()
struct A218_extra_required_alignment {
char a;
struct A218_extra_packed b;
};
struct A218_extra_required_alignment var235;
struct A218_extra_size {
char a[sizeof(A218)+1];
char b;
};
struct A218_extra_size var236;
#pragma pack(8)
typedef struct {
char c:1;
char d:8 __attribute__((packed));
char e:1;
} A219;
A219 var237;
#pragma pack()
struct A219_extra_alignment {
char a;
A219 b;
};
struct A219_extra_alignment var238;
#pragma pack(1)
struct A219_extra_packed {
A219 a;
};
#pragma pack()
struct A219_extra_required_alignment {
char a;
struct A219_extra_packed b;
};
struct A219_extra_required_alignment var239;
struct A219_extra_size {
char a[sizeof(A219)+1];
char b;
};
struct A219_extra_size var240;
typedef struct {
char c:2;
long d:1;
char e:1;
} A300;
A300 var241;
struct A300_extra_alignment {
char a;
A300 b;
};
struct A300_extra_alignment var242;
#pragma pack(1)
struct A300_extra_packed {
A300 a;
};
#pragma pack()
struct A300_extra_required_alignment {
char a;
struct A300_extra_packed b;
};
struct A300_extra_required_alignment var243;
struct A300_extra_size {
char a[sizeof(A300)+1];
char b;
};
struct A300_extra_size var244;
#pragma pack(1)
typedef struct {
char c:2;
long d:1;
char e:1;
} A301;
A301 var245;
#pragma pack()
struct A301_extra_alignment {
char a;
A301 b;
};
struct A301_extra_alignment var246;
#pragma pack(1)
struct A301_extra_packed {
A301 a;
};
#pragma pack()
struct A301_extra_required_alignment {
char a;
struct A301_extra_packed b;
};
struct A301_extra_required_alignment var247;
struct A301_extra_size {
char a[sizeof(A301)+1];
char b;
};
struct A301_extra_size var248;
#pragma pack(2)
typedef struct {
char c:2;
long d:1;
char e:1;
} A302;
A302 var249;
#pragma pack()
struct A302_extra_alignment {
char a;
A302 b;
};
struct A302_extra_alignment var250;
#pragma pack(1)
struct A302_extra_packed {
A302 a;
};
#pragma pack()
struct A302_extra_required_alignment {
char a;
struct A302_extra_packed b;
};
struct A302_extra_required_alignment var251;
struct A302_extra_size {
char a[sizeof(A302)+1];
char b;
};
struct A302_extra_size var252;
#pragma pack(4)
typedef struct {
char c:2;
long d:1;
char e:1;
} A303;
A303 var253;
#pragma pack()
struct A303_extra_alignment {
char a;
A303 b;
};
struct A303_extra_alignment var254;
#pragma pack(1)
struct A303_extra_packed {
A303 a;
};
#pragma pack()
struct A303_extra_required_alignment {
char a;
struct A303_extra_packed b;
};
struct A303_extra_required_alignment var255;
struct A303_extra_size {
char a[sizeof(A303)+1];
char b;
};
struct A303_extra_size var256;
#pragma pack(8)
typedef struct {
char c:2;
long d:1;
char e:1;
} A304;
A304 var257;
#pragma pack()
struct A304_extra_alignment {
char a;
A304 b;
};
struct A304_extra_alignment var258;
#pragma pack(1)
struct A304_extra_packed {
A304 a;
};
#pragma pack()
struct A304_extra_required_alignment {
char a;
struct A304_extra_packed b;
};
struct A304_extra_required_alignment var259;
struct A304_extra_size {
char a[sizeof(A304)+1];
char b;
};
struct A304_extra_size var260;
typedef struct {
char c:2;
long d:1 __attribute__((packed));
char e:1;
} A305;
A305 var261;
struct A305_extra_alignment {
char a;
A305 b;
};
struct A305_extra_alignment var262;
#pragma pack(1)
struct A305_extra_packed {
A305 a;
};
#pragma pack()
struct A305_extra_required_alignment {
char a;
struct A305_extra_packed b;
};
struct A305_extra_required_alignment var263;
struct A305_extra_size {
char a[sizeof(A305)+1];
char b;
};
struct A305_extra_size var264;
#pragma pack(1)
typedef struct {
char c:2;
long d:1 __attribute__((packed));
char e:1;
} A306;
A306 var265;
#pragma pack()
struct A306_extra_alignment {
char a;
A306 b;
};
struct A306_extra_alignment var266;
#pragma pack(1)
struct A306_extra_packed {
A306 a;
};
#pragma pack()
struct A306_extra_required_alignment {
char a;
struct A306_extra_packed b;
};
struct A306_extra_required_alignment var267;
struct A306_extra_size {
char a[sizeof(A306)+1];
char b;
};
struct A306_extra_size var268;
#pragma pack(2)
typedef struct {
char c:2;
long d:1 __attribute__((packed));
char e:1;
} A307;
A307 var269;
#pragma pack()
struct A307_extra_alignment {
char a;
A307 b;
};
struct A307_extra_alignment var270;
#pragma pack(1)
struct A307_extra_packed {
A307 a;
};
#pragma pack()
struct A307_extra_required_alignment {
char a;
struct A307_extra_packed b;
};
struct A307_extra_required_alignment var271;
struct A307_extra_size {
char a[sizeof(A307)+1];
char b;
};
struct A307_extra_size var272;
#pragma pack(4)
typedef struct {
char c:2;
long d:1 __attribute__((packed));
char e:1;
} A308;
A308 var273;
#pragma pack()
struct A308_extra_alignment {
char a;
A308 b;
};
struct A308_extra_alignment var274;
#pragma pack(1)
struct A308_extra_packed {
A308 a;
};
#pragma pack()
struct A308_extra_required_alignment {
char a;
struct A308_extra_packed b;
};
struct A308_extra_required_alignment var275;
struct A308_extra_size {
char a[sizeof(A308)+1];
char b;
};
struct A308_extra_size var276;
#pragma pack(8)
typedef struct {
char c:2;
long d:1 __attribute__((packed));
char e:1;
} A309;
A309 var277;
#pragma pack()
struct A309_extra_alignment {
char a;
A309 b;
};
struct A309_extra_alignment var278;
#pragma pack(1)
struct A309_extra_packed {
A309 a;
};
#pragma pack()
struct A309_extra_required_alignment {
char a;
struct A309_extra_packed b;
};
struct A309_extra_required_alignment var279;
struct A309_extra_size {
char a[sizeof(A309)+1];
char b;
};
struct A309_extra_size var280;
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1;
char e:1;
} A310;
A310 var281;
struct A310_extra_alignment {
char a;
A310 b;
};
struct A310_extra_alignment var282;
#pragma pack(1)
struct A310_extra_packed {
A310 a;
};
#pragma pack()
struct A310_extra_required_alignment {
char a;
struct A310_extra_packed b;
};
struct A310_extra_required_alignment var283;
struct A310_extra_size {
char a[sizeof(A310)+1];
char b;
};
struct A310_extra_size var284;
#pragma pack(1)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1;
char e:1;
} A311;
A311 var285;
#pragma pack()
struct A311_extra_alignment {
char a;
A311 b;
};
struct A311_extra_alignment var286;
#pragma pack(1)
struct A311_extra_packed {
A311 a;
};
#pragma pack()
struct A311_extra_required_alignment {
char a;
struct A311_extra_packed b;
};
struct A311_extra_required_alignment var287;
struct A311_extra_size {
char a[sizeof(A311)+1];
char b;
};
struct A311_extra_size var288;
#pragma pack(2)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1;
char e:1;
} A312;
A312 var289;
#pragma pack()
struct A312_extra_alignment {
char a;
A312 b;
};
struct A312_extra_alignment var290;
#pragma pack(1)
struct A312_extra_packed {
A312 a;
};
#pragma pack()
struct A312_extra_required_alignment {
char a;
struct A312_extra_packed b;
};
struct A312_extra_required_alignment var291;
struct A312_extra_size {
char a[sizeof(A312)+1];
char b;
};
struct A312_extra_size var292;
#pragma pack(4)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1;
char e:1;
} A313;
A313 var293;
#pragma pack()
struct A313_extra_alignment {
char a;
A313 b;
};
struct A313_extra_alignment var294;
#pragma pack(1)
struct A313_extra_packed {
A313 a;
};
#pragma pack()
struct A313_extra_required_alignment {
char a;
struct A313_extra_packed b;
};
struct A313_extra_required_alignment var295;
struct A313_extra_size {
char a[sizeof(A313)+1];
char b;
};
struct A313_extra_size var296;
#pragma pack(8)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1;
char e:1;
} A314;
A314 var297;
#pragma pack()
struct A314_extra_alignment {
char a;
A314 b;
};
struct A314_extra_alignment var298;
#pragma pack(1)
struct A314_extra_packed {
A314 a;
};
#pragma pack()
struct A314_extra_required_alignment {
char a;
struct A314_extra_packed b;
};
struct A314_extra_required_alignment var299;
struct A314_extra_size {
char a[sizeof(A314)+1];
char b;
};
struct A314_extra_size var300;
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((packed));
char e:1;
} A315;
A315 var301;
struct A315_extra_alignment {
char a;
A315 b;
};
struct A315_extra_alignment var302;
#pragma pack(1)
struct A315_extra_packed {
A315 a;
};
#pragma pack()
struct A315_extra_required_alignment {
char a;
struct A315_extra_packed b;
};
struct A315_extra_required_alignment var303;
struct A315_extra_size {
char a[sizeof(A315)+1];
char b;
};
struct A315_extra_size var304;
#pragma pack(1)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((packed));
char e:1;
} A316;
A316 var305;
#pragma pack()
struct A316_extra_alignment {
char a;
A316 b;
};
struct A316_extra_alignment var306;
#pragma pack(1)
struct A316_extra_packed {
A316 a;
};
#pragma pack()
struct A316_extra_required_alignment {
char a;
struct A316_extra_packed b;
};
struct A316_extra_required_alignment var307;
struct A316_extra_size {
char a[sizeof(A316)+1];
char b;
};
struct A316_extra_size var308;
#pragma pack(2)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((packed));
char e:1;
} A317;
A317 var309;
#pragma pack()
struct A317_extra_alignment {
char a;
A317 b;
};
struct A317_extra_alignment var310;
#pragma pack(1)
struct A317_extra_packed {
A317 a;
};
#pragma pack()
struct A317_extra_required_alignment {
char a;
struct A317_extra_packed b;
};
struct A317_extra_required_alignment var311;
struct A317_extra_size {
char a[sizeof(A317)+1];
char b;
};
struct A317_extra_size var312;
#pragma pack(4)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((packed));
char e:1;
} A318;
A318 var313;
#pragma pack()
struct A318_extra_alignment {
char a;
A318 b;
};
struct A318_extra_alignment var314;
#pragma pack(1)
struct A318_extra_packed {
A318 a;
};
#pragma pack()
struct A318_extra_required_alignment {
char a;
struct A318_extra_packed b;
};
struct A318_extra_required_alignment var315;
struct A318_extra_size {
char a[sizeof(A318)+1];
char b;
};
struct A318_extra_size var316;
#pragma pack(8)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((packed));
char e:1;
} A319;
A319 var317;
#pragma pack()
struct A319_extra_alignment {
char a;
A319 b;
};
struct A319_extra_alignment var318;
#pragma pack(1)
struct A319_extra_packed {
A319 a;
};
#pragma pack()
struct A319_extra_required_alignment {
char a;
struct A319_extra_packed b;
};
struct A319_extra_required_alignment var319;
struct A319_extra_size {
char a[sizeof(A319)+1];
char b;
};
struct A319_extra_size var320;
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(2)));
char e:1;
} A410;
A410 var321;
struct A410_extra_alignment {
char a;
A410 b;
};
struct A410_extra_alignment var322;
#pragma pack(1)
struct A410_extra_packed {
A410 a;
};
#pragma pack()
struct A410_extra_required_alignment {
char a;
struct A410_extra_packed b;
};
struct A410_extra_required_alignment var323;
struct A410_extra_size {
char a[sizeof(A410)+1];
char b;
};
struct A410_extra_size var324;
#pragma pack(1)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(2)));
char e:1;
} A411;
A411 var325;
#pragma pack()
struct A411_extra_alignment {
char a;
A411 b;
};
struct A411_extra_alignment var326;
#pragma pack(1)
struct A411_extra_packed {
A411 a;
};
#pragma pack()
struct A411_extra_required_alignment {
char a;
struct A411_extra_packed b;
};
struct A411_extra_required_alignment var327;
struct A411_extra_size {
char a[sizeof(A411)+1];
char b;
};
struct A411_extra_size var328;
#pragma pack(2)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4)));
char e:1;
} A412;
A412 var329;
#pragma pack()
struct A412_extra_alignment {
char a;
A412 b;
};
struct A412_extra_alignment var330;
#pragma pack(1)
struct A412_extra_packed {
A412 a;
};
#pragma pack()
struct A412_extra_required_alignment {
char a;
struct A412_extra_packed b;
};
struct A412_extra_required_alignment var331;
struct A412_extra_size {
char a[sizeof(A412)+1];
char b;
};
struct A412_extra_size var332;
#pragma pack(4)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4)));
char e:1;
} A413;
A413 var333;
#pragma pack()
struct A413_extra_alignment {
char a;
A413 b;
};
struct A413_extra_alignment var334;
#pragma pack(1)
struct A413_extra_packed {
A413 a;
};
#pragma pack()
struct A413_extra_required_alignment {
char a;
struct A413_extra_packed b;
};
struct A413_extra_required_alignment var335;
struct A413_extra_size {
char a[sizeof(A413)+1];
char b;
};
struct A413_extra_size var336;
#pragma pack(8)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4)));
char e:1;
} A414;
A414 var337;
#pragma pack()
struct A414_extra_alignment {
char a;
A414 b;
};
struct A414_extra_alignment var338;
#pragma pack(1)
struct A414_extra_packed {
A414 a;
};
#pragma pack()
struct A414_extra_required_alignment {
char a;
struct A414_extra_packed b;
};
struct A414_extra_required_alignment var339;
struct A414_extra_size {
char a[sizeof(A414)+1];
char b;
};
struct A414_extra_size var340;
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} A415;
A415 var341;
struct A415_extra_alignment {
char a;
A415 b;
};
struct A415_extra_alignment var342;
#pragma pack(1)
struct A415_extra_packed {
A415 a;
};
#pragma pack()
struct A415_extra_required_alignment {
char a;
struct A415_extra_packed b;
};
struct A415_extra_required_alignment var343;
struct A415_extra_size {
char a[sizeof(A415)+1];
char b;
};
struct A415_extra_size var344;
#pragma pack(1)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} A416;
A416 var345;
#pragma pack()
struct A416_extra_alignment {
char a;
A416 b;
};
struct A416_extra_alignment var346;
#pragma pack(1)
struct A416_extra_packed {
A416 a;
};
#pragma pack()
struct A416_extra_required_alignment {
char a;
struct A416_extra_packed b;
};
struct A416_extra_required_alignment var347;
struct A416_extra_size {
char a[sizeof(A416)+1];
char b;
};
struct A416_extra_size var348;
#pragma pack(2)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A417;
A417 var349;
#pragma pack()
struct A417_extra_alignment {
char a;
A417 b;
};
struct A417_extra_alignment var350;
#pragma pack(1)
struct A417_extra_packed {
A417 a;
};
#pragma pack()
struct A417_extra_required_alignment {
char a;
struct A417_extra_packed b;
};
struct A417_extra_required_alignment var351;
struct A417_extra_size {
char a[sizeof(A417)+1];
char b;
};
struct A417_extra_size var352;
#pragma pack(4)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A418;
A418 var353;
#pragma pack()
struct A418_extra_alignment {
char a;
A418 b;
};
struct A418_extra_alignment var354;
#pragma pack(1)
struct A418_extra_packed {
A418 a;
};
#pragma pack()
struct A418_extra_required_alignment {
char a;
struct A418_extra_packed b;
};
struct A418_extra_required_alignment var355;
struct A418_extra_size {
char a[sizeof(A418)+1];
char b;
};
struct A418_extra_size var356;
#pragma pack(8)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} A419;
A419 var357;
#pragma pack()
struct A419_extra_alignment {
char a;
A419 b;
};
struct A419_extra_alignment var358;
#pragma pack(1)
struct A419_extra_packed {
A419 a;
};
#pragma pack()
struct A419_extra_required_alignment {
char a;
struct A419_extra_packed b;
};
struct A419_extra_required_alignment var359;
struct A419_extra_size {
char a[sizeof(A419)+1];
char b;
};
struct A419_extra_size var360;
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2;
char e:1;
} A510;
A510 var361;
struct A510_extra_alignment {
char a;
A510 b;
};
struct A510_extra_alignment var362;
#pragma pack(1)
struct A510_extra_packed {
A510 a;
};
#pragma pack()
struct A510_extra_required_alignment {
char a;
struct A510_extra_packed b;
};
struct A510_extra_required_alignment var363;
struct A510_extra_size {
char a[sizeof(A510)+1];
char b;
};
struct A510_extra_size var364;
#pragma pack(1)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2;
char e:1;
} A511;
A511 var365;
#pragma pack()
struct A511_extra_alignment {
char a;
A511 b;
};
struct A511_extra_alignment var366;
#pragma pack(1)
struct A511_extra_packed {
A511 a;
};
#pragma pack()
struct A511_extra_required_alignment {
char a;
struct A511_extra_packed b;
};
struct A511_extra_required_alignment var367;
struct A511_extra_size {
char a[sizeof(A511)+1];
char b;
};
struct A511_extra_size var368;
#pragma pack(2)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2;
char e:1;
} A512;
A512 var369;
#pragma pack()
struct A512_extra_alignment {
char a;
A512 b;
};
struct A512_extra_alignment var370;
#pragma pack(1)
struct A512_extra_packed {
A512 a;
};
#pragma pack()
struct A512_extra_required_alignment {
char a;
struct A512_extra_packed b;
};
struct A512_extra_required_alignment var371;
struct A512_extra_size {
char a[sizeof(A512)+1];
char b;
};
struct A512_extra_size var372;
#pragma pack(4)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2;
char e:1;
} A513;
A513 var373;
#pragma pack()
struct A513_extra_alignment {
char a;
A513 b;
};
struct A513_extra_alignment var374;
#pragma pack(1)
struct A513_extra_packed {
A513 a;
};
#pragma pack()
struct A513_extra_required_alignment {
char a;
struct A513_extra_packed b;
};
struct A513_extra_required_alignment var375;
struct A513_extra_size {
char a[sizeof(A513)+1];
char b;
};
struct A513_extra_size var376;
#pragma pack(8)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2;
char e:1;
} A514;
A514 var377;
#pragma pack()
struct A514_extra_alignment {
char a;
A514 b;
};
struct A514_extra_alignment var378;
#pragma pack(1)
struct A514_extra_packed {
A514 a;
};
#pragma pack()
struct A514_extra_required_alignment {
char a;
struct A514_extra_packed b;
};
struct A514_extra_required_alignment var379;
struct A514_extra_size {
char a[sizeof(A514)+1];
char b;
};
struct A514_extra_size var380;
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((packed));
char e:1;
} A515;
A515 var381;
struct A515_extra_alignment {
char a;
A515 b;
};
struct A515_extra_alignment var382;
#pragma pack(1)
struct A515_extra_packed {
A515 a;
};
#pragma pack()
struct A515_extra_required_alignment {
char a;
struct A515_extra_packed b;
};
struct A515_extra_required_alignment var383;
struct A515_extra_size {
char a[sizeof(A515)+1];
char b;
};
struct A515_extra_size var384;
#pragma pack(1)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((packed));
char e:1;
} A516;
A516 var385;
#pragma pack()
struct A516_extra_alignment {
char a;
A516 b;
};
struct A516_extra_alignment var386;
#pragma pack(1)
struct A516_extra_packed {
A516 a;
};
#pragma pack()
struct A516_extra_required_alignment {
char a;
struct A516_extra_packed b;
};
struct A516_extra_required_alignment var387;
struct A516_extra_size {
char a[sizeof(A516)+1];
char b;
};
struct A516_extra_size var388;
#pragma pack(2)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((packed));
char e:1;
} A517;
A517 var389;
#pragma pack()
struct A517_extra_alignment {
char a;
A517 b;
};
struct A517_extra_alignment var390;
#pragma pack(1)
struct A517_extra_packed {
A517 a;
};
#pragma pack()
struct A517_extra_required_alignment {
char a;
struct A517_extra_packed b;
};
struct A517_extra_required_alignment var391;
struct A517_extra_size {
char a[sizeof(A517)+1];
char b;
};
struct A517_extra_size var392;
#pragma pack(4)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((packed));
char e:1;
} A518;
A518 var393;
#pragma pack()
struct A518_extra_alignment {
char a;
A518 b;
};
struct A518_extra_alignment var394;
#pragma pack(1)
struct A518_extra_packed {
A518 a;
};
#pragma pack()
struct A518_extra_required_alignment {
char a;
struct A518_extra_packed b;
};
struct A518_extra_required_alignment var395;
struct A518_extra_size {
char a[sizeof(A518)+1];
char b;
};
struct A518_extra_size var396;
#pragma pack(8)
typedef struct {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((packed));
char e:1;
} A519;
A519 var397;
#pragma pack()
struct A519_extra_alignment {
char a;
A519 b;
};
struct A519_extra_alignment var398;
#pragma pack(1)
struct A519_extra_packed {
A519 a;
};
#pragma pack()
struct A519_extra_required_alignment {
char a;
struct A519_extra_packed b;
};
struct A519_extra_required_alignment var399;
struct A519_extra_size {
char a[sizeof(A519)+1];
char b;
};
struct A519_extra_size var400;
typedef union {
char c:1;
char d:1 __attribute__((aligned(2)));
char e:1;
} B000;
B000 var401;
struct B000_extra_alignment {
char a;
B000 b;
};
struct B000_extra_alignment var402;
#pragma pack(1)
struct B000_extra_packed {
B000 a;
};
#pragma pack()
struct B000_extra_required_alignment {
char a;
struct B000_extra_packed b;
};
struct B000_extra_required_alignment var403;
struct B000_extra_size {
char a[sizeof(B000)+1];
char b;
};
struct B000_extra_size var404;
#pragma pack(1)
typedef union {
char c:1;
char d:1 __attribute__((aligned(2)));
char e:1;
} B001;
B001 var405;
#pragma pack()
struct B001_extra_alignment {
char a;
B001 b;
};
struct B001_extra_alignment var406;
#pragma pack(1)
struct B001_extra_packed {
B001 a;
};
#pragma pack()
struct B001_extra_required_alignment {
char a;
struct B001_extra_packed b;
};
struct B001_extra_required_alignment var407;
struct B001_extra_size {
char a[sizeof(B001)+1];
char b;
};
struct B001_extra_size var408;
#pragma pack(2)
typedef union {
char c:1;
char d:1 __attribute__((aligned(4)));
char e:1;
} B002;
B002 var409;
#pragma pack()
struct B002_extra_alignment {
char a;
B002 b;
};
struct B002_extra_alignment var410;
#pragma pack(1)
struct B002_extra_packed {
B002 a;
};
#pragma pack()
struct B002_extra_required_alignment {
char a;
struct B002_extra_packed b;
};
struct B002_extra_required_alignment var411;
struct B002_extra_size {
char a[sizeof(B002)+1];
char b;
};
struct B002_extra_size var412;
#pragma pack(4)
typedef union {
char c:1;
char d:1 __attribute__((aligned(4)));
char e:1;
} B003;
B003 var413;
#pragma pack()
struct B003_extra_alignment {
char a;
B003 b;
};
struct B003_extra_alignment var414;
#pragma pack(1)
struct B003_extra_packed {
B003 a;
};
#pragma pack()
struct B003_extra_required_alignment {
char a;
struct B003_extra_packed b;
};
struct B003_extra_required_alignment var415;
struct B003_extra_size {
char a[sizeof(B003)+1];
char b;
};
struct B003_extra_size var416;
#pragma pack(8)
typedef union {
char c:1;
char d:1 __attribute__((aligned(4)));
char e:1;
} B004;
B004 var417;
#pragma pack()
struct B004_extra_alignment {
char a;
B004 b;
};
struct B004_extra_alignment var418;
#pragma pack(1)
struct B004_extra_packed {
B004 a;
};
#pragma pack()
struct B004_extra_required_alignment {
char a;
struct B004_extra_packed b;
};
struct B004_extra_required_alignment var419;
struct B004_extra_size {
char a[sizeof(B004)+1];
char b;
};
struct B004_extra_size var420;
typedef union {
char c:1;
char d:1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} B005;
B005 var421;
struct B005_extra_alignment {
char a;
B005 b;
};
struct B005_extra_alignment var422;
#pragma pack(1)
struct B005_extra_packed {
B005 a;
};
#pragma pack()
struct B005_extra_required_alignment {
char a;
struct B005_extra_packed b;
};
struct B005_extra_required_alignment var423;
struct B005_extra_size {
char a[sizeof(B005)+1];
char b;
};
struct B005_extra_size var424;
#pragma pack(1)
typedef union {
char c:1;
char d:1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} B006;
B006 var425;
#pragma pack()
struct B006_extra_alignment {
char a;
B006 b;
};
struct B006_extra_alignment var426;
#pragma pack(1)
struct B006_extra_packed {
B006 a;
};
#pragma pack()
struct B006_extra_required_alignment {
char a;
struct B006_extra_packed b;
};
struct B006_extra_required_alignment var427;
struct B006_extra_size {
char a[sizeof(B006)+1];
char b;
};
struct B006_extra_size var428;
#pragma pack(2)
typedef union {
char c:1;
char d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B007;
B007 var429;
#pragma pack()
struct B007_extra_alignment {
char a;
B007 b;
};
struct B007_extra_alignment var430;
#pragma pack(1)
struct B007_extra_packed {
B007 a;
};
#pragma pack()
struct B007_extra_required_alignment {
char a;
struct B007_extra_packed b;
};
struct B007_extra_required_alignment var431;
struct B007_extra_size {
char a[sizeof(B007)+1];
char b;
};
struct B007_extra_size var432;
#pragma pack(4)
typedef union {
char c:1;
char d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B008;
B008 var433;
#pragma pack()
struct B008_extra_alignment {
char a;
B008 b;
};
struct B008_extra_alignment var434;
#pragma pack(1)
struct B008_extra_packed {
B008 a;
};
#pragma pack()
struct B008_extra_required_alignment {
char a;
struct B008_extra_packed b;
};
struct B008_extra_required_alignment var435;
struct B008_extra_size {
char a[sizeof(B008)+1];
char b;
};
struct B008_extra_size var436;
#pragma pack(8)
typedef union {
char c:1;
char d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B009;
B009 var437;
#pragma pack()
struct B009_extra_alignment {
char a;
B009 b;
};
struct B009_extra_alignment var438;
#pragma pack(1)
struct B009_extra_packed {
B009 a;
};
#pragma pack()
struct B009_extra_required_alignment {
char a;
struct B009_extra_packed b;
};
struct B009_extra_required_alignment var439;
struct B009_extra_size {
char a[sizeof(B009)+1];
char b;
};
struct B009_extra_size var440;
typedef union {
char c:1;
char d:8 __attribute__((aligned(2)));
char e:1;
} B010;
B010 var441;
struct B010_extra_alignment {
char a;
B010 b;
};
struct B010_extra_alignment var442;
#pragma pack(1)
struct B010_extra_packed {
B010 a;
};
#pragma pack()
struct B010_extra_required_alignment {
char a;
struct B010_extra_packed b;
};
struct B010_extra_required_alignment var443;
struct B010_extra_size {
char a[sizeof(B010)+1];
char b;
};
struct B010_extra_size var444;
#pragma pack(1)
typedef union {
char c:1;
char d:8 __attribute__((aligned(2)));
char e:1;
} B011;
B011 var445;
#pragma pack()
struct B011_extra_alignment {
char a;
B011 b;
};
struct B011_extra_alignment var446;
#pragma pack(1)
struct B011_extra_packed {
B011 a;
};
#pragma pack()
struct B011_extra_required_alignment {
char a;
struct B011_extra_packed b;
};
struct B011_extra_required_alignment var447;
struct B011_extra_size {
char a[sizeof(B011)+1];
char b;
};
struct B011_extra_size var448;
#pragma pack(2)
typedef union {
char c:1;
char d:8 __attribute__((aligned(4)));
char e:1;
} B012;
B012 var449;
#pragma pack()
struct B012_extra_alignment {
char a;
B012 b;
};
struct B012_extra_alignment var450;
#pragma pack(1)
struct B012_extra_packed {
B012 a;
};
#pragma pack()
struct B012_extra_required_alignment {
char a;
struct B012_extra_packed b;
};
struct B012_extra_required_alignment var451;
struct B012_extra_size {
char a[sizeof(B012)+1];
char b;
};
struct B012_extra_size var452;
#pragma pack(4)
typedef union {
char c:1;
char d:8 __attribute__((aligned(4)));
char e:1;
} B013;
B013 var453;
#pragma pack()
struct B013_extra_alignment {
char a;
B013 b;
};
struct B013_extra_alignment var454;
#pragma pack(1)
struct B013_extra_packed {
B013 a;
};
#pragma pack()
struct B013_extra_required_alignment {
char a;
struct B013_extra_packed b;
};
struct B013_extra_required_alignment var455;
struct B013_extra_size {
char a[sizeof(B013)+1];
char b;
};
struct B013_extra_size var456;
#pragma pack(8)
typedef union {
char c:1;
char d:8 __attribute__((aligned(4)));
char e:1;
} B014;
B014 var457;
#pragma pack()
struct B014_extra_alignment {
char a;
B014 b;
};
struct B014_extra_alignment var458;
#pragma pack(1)
struct B014_extra_packed {
B014 a;
};
#pragma pack()
struct B014_extra_required_alignment {
char a;
struct B014_extra_packed b;
};
struct B014_extra_required_alignment var459;
struct B014_extra_size {
char a[sizeof(B014)+1];
char b;
};
struct B014_extra_size var460;
typedef union {
char c:1;
char d:8 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} B015;
B015 var461;
struct B015_extra_alignment {
char a;
B015 b;
};
struct B015_extra_alignment var462;
#pragma pack(1)
struct B015_extra_packed {
B015 a;
};
#pragma pack()
struct B015_extra_required_alignment {
char a;
struct B015_extra_packed b;
};
struct B015_extra_required_alignment var463;
struct B015_extra_size {
char a[sizeof(B015)+1];
char b;
};
struct B015_extra_size var464;
#pragma pack(1)
typedef union {
char c:1;
char d:8 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} B016;
B016 var465;
#pragma pack()
struct B016_extra_alignment {
char a;
B016 b;
};
struct B016_extra_alignment var466;
#pragma pack(1)
struct B016_extra_packed {
B016 a;
};
#pragma pack()
struct B016_extra_required_alignment {
char a;
struct B016_extra_packed b;
};
struct B016_extra_required_alignment var467;
struct B016_extra_size {
char a[sizeof(B016)+1];
char b;
};
struct B016_extra_size var468;
#pragma pack(2)
typedef union {
char c:1;
char d:8 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B017;
B017 var469;
#pragma pack()
struct B017_extra_alignment {
char a;
B017 b;
};
struct B017_extra_alignment var470;
#pragma pack(1)
struct B017_extra_packed {
B017 a;
};
#pragma pack()
struct B017_extra_required_alignment {
char a;
struct B017_extra_packed b;
};
struct B017_extra_required_alignment var471;
struct B017_extra_size {
char a[sizeof(B017)+1];
char b;
};
struct B017_extra_size var472;
#pragma pack(4)
typedef union {
char c:1;
char d:8 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B018;
B018 var473;
#pragma pack()
struct B018_extra_alignment {
char a;
B018 b;
};
struct B018_extra_alignment var474;
#pragma pack(1)
struct B018_extra_packed {
B018 a;
};
#pragma pack()
struct B018_extra_required_alignment {
char a;
struct B018_extra_packed b;
};
struct B018_extra_required_alignment var475;
struct B018_extra_size {
char a[sizeof(B018)+1];
char b;
};
struct B018_extra_size var476;
#pragma pack(8)
typedef union {
char c:1;
char d:8 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B019;
B019 var477;
#pragma pack()
struct B019_extra_alignment {
char a;
B019 b;
};
struct B019_extra_alignment var478;
#pragma pack(1)
struct B019_extra_packed {
B019 a;
};
#pragma pack()
struct B019_extra_required_alignment {
char a;
struct B019_extra_packed b;
};
struct B019_extra_required_alignment var479;
struct B019_extra_size {
char a[sizeof(B019)+1];
char b;
};
struct B019_extra_size var480;
typedef union {
char c:2;
long d:1 __attribute__((aligned(2)));
char e:1;
} B100;
B100 var481;
struct B100_extra_alignment {
char a;
B100 b;
};
struct B100_extra_alignment var482;
#pragma pack(1)
struct B100_extra_packed {
B100 a;
};
#pragma pack()
struct B100_extra_required_alignment {
char a;
struct B100_extra_packed b;
};
struct B100_extra_required_alignment var483;
struct B100_extra_size {
char a[sizeof(B100)+1];
char b;
};
struct B100_extra_size var484;
#pragma pack(1)
typedef union {
char c:2;
long d:1 __attribute__((aligned(2)));
char e:1;
} B101;
B101 var485;
#pragma pack()
struct B101_extra_alignment {
char a;
B101 b;
};
struct B101_extra_alignment var486;
#pragma pack(1)
struct B101_extra_packed {
B101 a;
};
#pragma pack()
struct B101_extra_required_alignment {
char a;
struct B101_extra_packed b;
};
struct B101_extra_required_alignment var487;
struct B101_extra_size {
char a[sizeof(B101)+1];
char b;
};
struct B101_extra_size var488;
#pragma pack(2)
typedef union {
char c:2;
long d:1 __attribute__((aligned(4)));
char e:1;
} B102;
B102 var489;
#pragma pack()
struct B102_extra_alignment {
char a;
B102 b;
};
struct B102_extra_alignment var490;
#pragma pack(1)
struct B102_extra_packed {
B102 a;
};
#pragma pack()
struct B102_extra_required_alignment {
char a;
struct B102_extra_packed b;
};
struct B102_extra_required_alignment var491;
struct B102_extra_size {
char a[sizeof(B102)+1];
char b;
};
struct B102_extra_size var492;
#pragma pack(4)
typedef union {
char c:2;
long d:1 __attribute__((aligned(4)));
char e:1;
} B103;
B103 var493;
#pragma pack()
struct B103_extra_alignment {
char a;
B103 b;
};
struct B103_extra_alignment var494;
#pragma pack(1)
struct B103_extra_packed {
B103 a;
};
#pragma pack()
struct B103_extra_required_alignment {
char a;
struct B103_extra_packed b;
};
struct B103_extra_required_alignment var495;
struct B103_extra_size {
char a[sizeof(B103)+1];
char b;
};
struct B103_extra_size var496;
#pragma pack(8)
typedef union {
char c:2;
long d:1 __attribute__((aligned(4)));
char e:1;
} B104;
B104 var497;
#pragma pack()
struct B104_extra_alignment {
char a;
B104 b;
};
struct B104_extra_alignment var498;
#pragma pack(1)
struct B104_extra_packed {
B104 a;
};
#pragma pack()
struct B104_extra_required_alignment {
char a;
struct B104_extra_packed b;
};
struct B104_extra_required_alignment var499;
struct B104_extra_size {
char a[sizeof(B104)+1];
char b;
};
struct B104_extra_size var500;
typedef union {
char c:2;
long d:1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} B105;
B105 var501;
struct B105_extra_alignment {
char a;
B105 b;
};
struct B105_extra_alignment var502;
#pragma pack(1)
struct B105_extra_packed {
B105 a;
};
#pragma pack()
struct B105_extra_required_alignment {
char a;
struct B105_extra_packed b;
};
struct B105_extra_required_alignment var503;
struct B105_extra_size {
char a[sizeof(B105)+1];
char b;
};
struct B105_extra_size var504;
#pragma pack(1)
typedef union {
char c:2;
long d:1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} B106;
B106 var505;
#pragma pack()
struct B106_extra_alignment {
char a;
B106 b;
};
struct B106_extra_alignment var506;
#pragma pack(1)
struct B106_extra_packed {
B106 a;
};
#pragma pack()
struct B106_extra_required_alignment {
char a;
struct B106_extra_packed b;
};
struct B106_extra_required_alignment var507;
struct B106_extra_size {
char a[sizeof(B106)+1];
char b;
};
struct B106_extra_size var508;
#pragma pack(2)
typedef union {
char c:2;
long d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B107;
B107 var509;
#pragma pack()
struct B107_extra_alignment {
char a;
B107 b;
};
struct B107_extra_alignment var510;
#pragma pack(1)
struct B107_extra_packed {
B107 a;
};
#pragma pack()
struct B107_extra_required_alignment {
char a;
struct B107_extra_packed b;
};
struct B107_extra_required_alignment var511;
struct B107_extra_size {
char a[sizeof(B107)+1];
char b;
};
struct B107_extra_size var512;
#pragma pack(4)
typedef union {
char c:2;
long d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B108;
B108 var513;
#pragma pack()
struct B108_extra_alignment {
char a;
B108 b;
};
struct B108_extra_alignment var514;
#pragma pack(1)
struct B108_extra_packed {
B108 a;
};
#pragma pack()
struct B108_extra_required_alignment {
char a;
struct B108_extra_packed b;
};
struct B108_extra_required_alignment var515;
struct B108_extra_size {
char a[sizeof(B108)+1];
char b;
};
struct B108_extra_size var516;
#pragma pack(8)
typedef union {
char c:2;
long d:1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B109;
B109 var517;
#pragma pack()
struct B109_extra_alignment {
char a;
B109 b;
};
struct B109_extra_alignment var518;
#pragma pack(1)
struct B109_extra_packed {
B109 a;
};
#pragma pack()
struct B109_extra_required_alignment {
char a;
struct B109_extra_packed b;
};
struct B109_extra_required_alignment var519;
struct B109_extra_size {
char a[sizeof(B109)+1];
char b;
};
struct B109_extra_size var520;
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(2)));
char e:1;
} B110;
B110 var521;
struct B110_extra_alignment {
char a;
B110 b;
};
struct B110_extra_alignment var522;
#pragma pack(1)
struct B110_extra_packed {
B110 a;
};
#pragma pack()
struct B110_extra_required_alignment {
char a;
struct B110_extra_packed b;
};
struct B110_extra_required_alignment var523;
struct B110_extra_size {
char a[sizeof(B110)+1];
char b;
};
struct B110_extra_size var524;
#pragma pack(1)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(2)));
char e:1;
} B111;
B111 var525;
#pragma pack()
struct B111_extra_alignment {
char a;
B111 b;
};
struct B111_extra_alignment var526;
#pragma pack(1)
struct B111_extra_packed {
B111 a;
};
#pragma pack()
struct B111_extra_required_alignment {
char a;
struct B111_extra_packed b;
};
struct B111_extra_required_alignment var527;
struct B111_extra_size {
char a[sizeof(B111)+1];
char b;
};
struct B111_extra_size var528;
#pragma pack(2)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4)));
char e:1;
} B112;
B112 var529;
#pragma pack()
struct B112_extra_alignment {
char a;
B112 b;
};
struct B112_extra_alignment var530;
#pragma pack(1)
struct B112_extra_packed {
B112 a;
};
#pragma pack()
struct B112_extra_required_alignment {
char a;
struct B112_extra_packed b;
};
struct B112_extra_required_alignment var531;
struct B112_extra_size {
char a[sizeof(B112)+1];
char b;
};
struct B112_extra_size var532;
#pragma pack(4)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4)));
char e:1;
} B113;
B113 var533;
#pragma pack()
struct B113_extra_alignment {
char a;
B113 b;
};
struct B113_extra_alignment var534;
#pragma pack(1)
struct B113_extra_packed {
B113 a;
};
#pragma pack()
struct B113_extra_required_alignment {
char a;
struct B113_extra_packed b;
};
struct B113_extra_required_alignment var535;
struct B113_extra_size {
char a[sizeof(B113)+1];
char b;
};
struct B113_extra_size var536;
#pragma pack(8)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4)));
char e:1;
} B114;
B114 var537;
#pragma pack()
struct B114_extra_alignment {
char a;
B114 b;
};
struct B114_extra_alignment var538;
#pragma pack(1)
struct B114_extra_packed {
B114 a;
};
#pragma pack()
struct B114_extra_required_alignment {
char a;
struct B114_extra_packed b;
};
struct B114_extra_required_alignment var539;
struct B114_extra_size {
char a[sizeof(B114)+1];
char b;
};
struct B114_extra_size var540;
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} B115;
B115 var541;
struct B115_extra_alignment {
char a;
B115 b;
};
struct B115_extra_alignment var542;
#pragma pack(1)
struct B115_extra_packed {
B115 a;
};
#pragma pack()
struct B115_extra_required_alignment {
char a;
struct B115_extra_packed b;
};
struct B115_extra_required_alignment var543;
struct B115_extra_size {
char a[sizeof(B115)+1];
char b;
};
struct B115_extra_size var544;
#pragma pack(1)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} B116;
B116 var545;
#pragma pack()
struct B116_extra_alignment {
char a;
B116 b;
};
struct B116_extra_alignment var546;
#pragma pack(1)
struct B116_extra_packed {
B116 a;
};
#pragma pack()
struct B116_extra_required_alignment {
char a;
struct B116_extra_packed b;
};
struct B116_extra_required_alignment var547;
struct B116_extra_size {
char a[sizeof(B116)+1];
char b;
};
struct B116_extra_size var548;
#pragma pack(2)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B117;
B117 var549;
#pragma pack()
struct B117_extra_alignment {
char a;
B117 b;
};
struct B117_extra_alignment var550;
#pragma pack(1)
struct B117_extra_packed {
B117 a;
};
#pragma pack()
struct B117_extra_required_alignment {
char a;
struct B117_extra_packed b;
};
struct B117_extra_required_alignment var551;
struct B117_extra_size {
char a[sizeof(B117)+1];
char b;
};
struct B117_extra_size var552;
#pragma pack(4)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B118;
B118 var553;
#pragma pack()
struct B118_extra_alignment {
char a;
B118 b;
};
struct B118_extra_alignment var554;
#pragma pack(1)
struct B118_extra_packed {
B118 a;
};
#pragma pack()
struct B118_extra_required_alignment {
char a;
struct B118_extra_packed b;
};
struct B118_extra_required_alignment var555;
struct B118_extra_size {
char a[sizeof(B118)+1];
char b;
};
struct B118_extra_size var556;
#pragma pack(8)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B119;
B119 var557;
#pragma pack()
struct B119_extra_alignment {
char a;
B119 b;
};
struct B119_extra_alignment var558;
#pragma pack(1)
struct B119_extra_packed {
B119 a;
};
#pragma pack()
struct B119_extra_required_alignment {
char a;
struct B119_extra_packed b;
};
struct B119_extra_required_alignment var559;
struct B119_extra_size {
char a[sizeof(B119)+1];
char b;
};
struct B119_extra_size var560;
typedef union {
char c:1;
char d:1;
char e:1;
} B200;
B200 var561;
struct B200_extra_alignment {
char a;
B200 b;
};
struct B200_extra_alignment var562;
#pragma pack(1)
struct B200_extra_packed {
B200 a;
};
#pragma pack()
struct B200_extra_required_alignment {
char a;
struct B200_extra_packed b;
};
struct B200_extra_required_alignment var563;
struct B200_extra_size {
char a[sizeof(B200)+1];
char b;
};
struct B200_extra_size var564;
#pragma pack(1)
typedef union {
char c:1;
char d:1;
char e:1;
} B201;
B201 var565;
#pragma pack()
struct B201_extra_alignment {
char a;
B201 b;
};
struct B201_extra_alignment var566;
#pragma pack(1)
struct B201_extra_packed {
B201 a;
};
#pragma pack()
struct B201_extra_required_alignment {
char a;
struct B201_extra_packed b;
};
struct B201_extra_required_alignment var567;
struct B201_extra_size {
char a[sizeof(B201)+1];
char b;
};
struct B201_extra_size var568;
#pragma pack(2)
typedef union {
char c:1;
char d:1;
char e:1;
} B202;
B202 var569;
#pragma pack()
struct B202_extra_alignment {
char a;
B202 b;
};
struct B202_extra_alignment var570;
#pragma pack(1)
struct B202_extra_packed {
B202 a;
};
#pragma pack()
struct B202_extra_required_alignment {
char a;
struct B202_extra_packed b;
};
struct B202_extra_required_alignment var571;
struct B202_extra_size {
char a[sizeof(B202)+1];
char b;
};
struct B202_extra_size var572;
#pragma pack(4)
typedef union {
char c:1;
char d:1;
char e:1;
} B203;
B203 var573;
#pragma pack()
struct B203_extra_alignment {
char a;
B203 b;
};
struct B203_extra_alignment var574;
#pragma pack(1)
struct B203_extra_packed {
B203 a;
};
#pragma pack()
struct B203_extra_required_alignment {
char a;
struct B203_extra_packed b;
};
struct B203_extra_required_alignment var575;
struct B203_extra_size {
char a[sizeof(B203)+1];
char b;
};
struct B203_extra_size var576;
#pragma pack(8)
typedef union {
char c:1;
char d:1;
char e:1;
} B204;
B204 var577;
#pragma pack()
struct B204_extra_alignment {
char a;
B204 b;
};
struct B204_extra_alignment var578;
#pragma pack(1)
struct B204_extra_packed {
B204 a;
};
#pragma pack()
struct B204_extra_required_alignment {
char a;
struct B204_extra_packed b;
};
struct B204_extra_required_alignment var579;
struct B204_extra_size {
char a[sizeof(B204)+1];
char b;
};
struct B204_extra_size var580;
typedef union {
char c:1;
char d:1 __attribute__((packed));
char e:1;
} B205;
B205 var581;
struct B205_extra_alignment {
char a;
B205 b;
};
struct B205_extra_alignment var582;
#pragma pack(1)
struct B205_extra_packed {
B205 a;
};
#pragma pack()
struct B205_extra_required_alignment {
char a;
struct B205_extra_packed b;
};
struct B205_extra_required_alignment var583;
struct B205_extra_size {
char a[sizeof(B205)+1];
char b;
};
struct B205_extra_size var584;
#pragma pack(1)
typedef union {
char c:1;
char d:1 __attribute__((packed));
char e:1;
} B206;
B206 var585;
#pragma pack()
struct B206_extra_alignment {
char a;
B206 b;
};
struct B206_extra_alignment var586;
#pragma pack(1)
struct B206_extra_packed {
B206 a;
};
#pragma pack()
struct B206_extra_required_alignment {
char a;
struct B206_extra_packed b;
};
struct B206_extra_required_alignment var587;
struct B206_extra_size {
char a[sizeof(B206)+1];
char b;
};
struct B206_extra_size var588;
#pragma pack(2)
typedef union {
char c:1;
char d:1 __attribute__((packed));
char e:1;
} B207;
B207 var589;
#pragma pack()
struct B207_extra_alignment {
char a;
B207 b;
};
struct B207_extra_alignment var590;
#pragma pack(1)
struct B207_extra_packed {
B207 a;
};
#pragma pack()
struct B207_extra_required_alignment {
char a;
struct B207_extra_packed b;
};
struct B207_extra_required_alignment var591;
struct B207_extra_size {
char a[sizeof(B207)+1];
char b;
};
struct B207_extra_size var592;
#pragma pack(4)
typedef union {
char c:1;
char d:1 __attribute__((packed));
char e:1;
} B208;
B208 var593;
#pragma pack()
struct B208_extra_alignment {
char a;
B208 b;
};
struct B208_extra_alignment var594;
#pragma pack(1)
struct B208_extra_packed {
B208 a;
};
#pragma pack()
struct B208_extra_required_alignment {
char a;
struct B208_extra_packed b;
};
struct B208_extra_required_alignment var595;
struct B208_extra_size {
char a[sizeof(B208)+1];
char b;
};
struct B208_extra_size var596;
#pragma pack(8)
typedef union {
char c:1;
char d:1 __attribute__((packed));
char e:1;
} B209;
B209 var597;
#pragma pack()
struct B209_extra_alignment {
char a;
B209 b;
};
struct B209_extra_alignment var598;
#pragma pack(1)
struct B209_extra_packed {
B209 a;
};
#pragma pack()
struct B209_extra_required_alignment {
char a;
struct B209_extra_packed b;
};
struct B209_extra_required_alignment var599;
struct B209_extra_size {
char a[sizeof(B209)+1];
char b;
};
struct B209_extra_size var600;
typedef union {
char c:1;
char d:8;
char e:1;
} B210;
B210 var601;
struct B210_extra_alignment {
char a;
B210 b;
};
struct B210_extra_alignment var602;
#pragma pack(1)
struct B210_extra_packed {
B210 a;
};
#pragma pack()
struct B210_extra_required_alignment {
char a;
struct B210_extra_packed b;
};
struct B210_extra_required_alignment var603;
struct B210_extra_size {
char a[sizeof(B210)+1];
char b;
};
struct B210_extra_size var604;
#pragma pack(1)
typedef union {
char c:1;
char d:8;
char e:1;
} B211;
B211 var605;
#pragma pack()
struct B211_extra_alignment {
char a;
B211 b;
};
struct B211_extra_alignment var606;
#pragma pack(1)
struct B211_extra_packed {
B211 a;
};
#pragma pack()
struct B211_extra_required_alignment {
char a;
struct B211_extra_packed b;
};
struct B211_extra_required_alignment var607;
struct B211_extra_size {
char a[sizeof(B211)+1];
char b;
};
struct B211_extra_size var608;
#pragma pack(2)
typedef union {
char c:1;
char d:8;
char e:1;
} B212;
B212 var609;
#pragma pack()
struct B212_extra_alignment {
char a;
B212 b;
};
struct B212_extra_alignment var610;
#pragma pack(1)
struct B212_extra_packed {
B212 a;
};
#pragma pack()
struct B212_extra_required_alignment {
char a;
struct B212_extra_packed b;
};
struct B212_extra_required_alignment var611;
struct B212_extra_size {
char a[sizeof(B212)+1];
char b;
};
struct B212_extra_size var612;
#pragma pack(4)
typedef union {
char c:1;
char d:8;
char e:1;
} B213;
B213 var613;
#pragma pack()
struct B213_extra_alignment {
char a;
B213 b;
};
struct B213_extra_alignment var614;
#pragma pack(1)
struct B213_extra_packed {
B213 a;
};
#pragma pack()
struct B213_extra_required_alignment {
char a;
struct B213_extra_packed b;
};
struct B213_extra_required_alignment var615;
struct B213_extra_size {
char a[sizeof(B213)+1];
char b;
};
struct B213_extra_size var616;
#pragma pack(8)
typedef union {
char c:1;
char d:8;
char e:1;
} B214;
B214 var617;
#pragma pack()
struct B214_extra_alignment {
char a;
B214 b;
};
struct B214_extra_alignment var618;
#pragma pack(1)
struct B214_extra_packed {
B214 a;
};
#pragma pack()
struct B214_extra_required_alignment {
char a;
struct B214_extra_packed b;
};
struct B214_extra_required_alignment var619;
struct B214_extra_size {
char a[sizeof(B214)+1];
char b;
};
struct B214_extra_size var620;
typedef union {
char c:1;
char d:8 __attribute__((packed));
char e:1;
} B215;
B215 var621;
struct B215_extra_alignment {
char a;
B215 b;
};
struct B215_extra_alignment var622;
#pragma pack(1)
struct B215_extra_packed {
B215 a;
};
#pragma pack()
struct B215_extra_required_alignment {
char a;
struct B215_extra_packed b;
};
struct B215_extra_required_alignment var623;
struct B215_extra_size {
char a[sizeof(B215)+1];
char b;
};
struct B215_extra_size var624;
#pragma pack(1)
typedef union {
char c:1;
char d:8 __attribute__((packed));
char e:1;
} B216;
B216 var625;
#pragma pack()
struct B216_extra_alignment {
char a;
B216 b;
};
struct B216_extra_alignment var626;
#pragma pack(1)
struct B216_extra_packed {
B216 a;
};
#pragma pack()
struct B216_extra_required_alignment {
char a;
struct B216_extra_packed b;
};
struct B216_extra_required_alignment var627;
struct B216_extra_size {
char a[sizeof(B216)+1];
char b;
};
struct B216_extra_size var628;
#pragma pack(2)
typedef union {
char c:1;
char d:8 __attribute__((packed));
char e:1;
} B217;
B217 var629;
#pragma pack()
struct B217_extra_alignment {
char a;
B217 b;
};
struct B217_extra_alignment var630;
#pragma pack(1)
struct B217_extra_packed {
B217 a;
};
#pragma pack()
struct B217_extra_required_alignment {
char a;
struct B217_extra_packed b;
};
struct B217_extra_required_alignment var631;
struct B217_extra_size {
char a[sizeof(B217)+1];
char b;
};
struct B217_extra_size var632;
#pragma pack(4)
typedef union {
char c:1;
char d:8 __attribute__((packed));
char e:1;
} B218;
B218 var633;
#pragma pack()
struct B218_extra_alignment {
char a;
B218 b;
};
struct B218_extra_alignment var634;
#pragma pack(1)
struct B218_extra_packed {
B218 a;
};
#pragma pack()
struct B218_extra_required_alignment {
char a;
struct B218_extra_packed b;
};
struct B218_extra_required_alignment var635;
struct B218_extra_size {
char a[sizeof(B218)+1];
char b;
};
struct B218_extra_size var636;
#pragma pack(8)
typedef union {
char c:1;
char d:8 __attribute__((packed));
char e:1;
} B219;
B219 var637;
#pragma pack()
struct B219_extra_alignment {
char a;
B219 b;
};
struct B219_extra_alignment var638;
#pragma pack(1)
struct B219_extra_packed {
B219 a;
};
#pragma pack()
struct B219_extra_required_alignment {
char a;
struct B219_extra_packed b;
};
struct B219_extra_required_alignment var639;
struct B219_extra_size {
char a[sizeof(B219)+1];
char b;
};
struct B219_extra_size var640;
typedef union {
char c:2;
long d:1;
char e:1;
} B300;
B300 var641;
struct B300_extra_alignment {
char a;
B300 b;
};
struct B300_extra_alignment var642;
#pragma pack(1)
struct B300_extra_packed {
B300 a;
};
#pragma pack()
struct B300_extra_required_alignment {
char a;
struct B300_extra_packed b;
};
struct B300_extra_required_alignment var643;
struct B300_extra_size {
char a[sizeof(B300)+1];
char b;
};
struct B300_extra_size var644;
#pragma pack(1)
typedef union {
char c:2;
long d:1;
char e:1;
} B301;
B301 var645;
#pragma pack()
struct B301_extra_alignment {
char a;
B301 b;
};
struct B301_extra_alignment var646;
#pragma pack(1)
struct B301_extra_packed {
B301 a;
};
#pragma pack()
struct B301_extra_required_alignment {
char a;
struct B301_extra_packed b;
};
struct B301_extra_required_alignment var647;
struct B301_extra_size {
char a[sizeof(B301)+1];
char b;
};
struct B301_extra_size var648;
#pragma pack(2)
typedef union {
char c:2;
long d:1;
char e:1;
} B302;
B302 var649;
#pragma pack()
struct B302_extra_alignment {
char a;
B302 b;
};
struct B302_extra_alignment var650;
#pragma pack(1)
struct B302_extra_packed {
B302 a;
};
#pragma pack()
struct B302_extra_required_alignment {
char a;
struct B302_extra_packed b;
};
struct B302_extra_required_alignment var651;
struct B302_extra_size {
char a[sizeof(B302)+1];
char b;
};
struct B302_extra_size var652;
#pragma pack(4)
typedef union {
char c:2;
long d:1;
char e:1;
} B303;
B303 var653;
#pragma pack()
struct B303_extra_alignment {
char a;
B303 b;
};
struct B303_extra_alignment var654;
#pragma pack(1)
struct B303_extra_packed {
B303 a;
};
#pragma pack()
struct B303_extra_required_alignment {
char a;
struct B303_extra_packed b;
};
struct B303_extra_required_alignment var655;
struct B303_extra_size {
char a[sizeof(B303)+1];
char b;
};
struct B303_extra_size var656;
#pragma pack(8)
typedef union {
char c:2;
long d:1;
char e:1;
} B304;
B304 var657;
#pragma pack()
struct B304_extra_alignment {
char a;
B304 b;
};
struct B304_extra_alignment var658;
#pragma pack(1)
struct B304_extra_packed {
B304 a;
};
#pragma pack()
struct B304_extra_required_alignment {
char a;
struct B304_extra_packed b;
};
struct B304_extra_required_alignment var659;
struct B304_extra_size {
char a[sizeof(B304)+1];
char b;
};
struct B304_extra_size var660;
typedef union {
char c:2;
long d:1 __attribute__((packed));
char e:1;
} B305;
B305 var661;
struct B305_extra_alignment {
char a;
B305 b;
};
struct B305_extra_alignment var662;
#pragma pack(1)
struct B305_extra_packed {
B305 a;
};
#pragma pack()
struct B305_extra_required_alignment {
char a;
struct B305_extra_packed b;
};
struct B305_extra_required_alignment var663;
struct B305_extra_size {
char a[sizeof(B305)+1];
char b;
};
struct B305_extra_size var664;
#pragma pack(1)
typedef union {
char c:2;
long d:1 __attribute__((packed));
char e:1;
} B306;
B306 var665;
#pragma pack()
struct B306_extra_alignment {
char a;
B306 b;
};
struct B306_extra_alignment var666;
#pragma pack(1)
struct B306_extra_packed {
B306 a;
};
#pragma pack()
struct B306_extra_required_alignment {
char a;
struct B306_extra_packed b;
};
struct B306_extra_required_alignment var667;
struct B306_extra_size {
char a[sizeof(B306)+1];
char b;
};
struct B306_extra_size var668;
#pragma pack(2)
typedef union {
char c:2;
long d:1 __attribute__((packed));
char e:1;
} B307;
B307 var669;
#pragma pack()
struct B307_extra_alignment {
char a;
B307 b;
};
struct B307_extra_alignment var670;
#pragma pack(1)
struct B307_extra_packed {
B307 a;
};
#pragma pack()
struct B307_extra_required_alignment {
char a;
struct B307_extra_packed b;
};
struct B307_extra_required_alignment var671;
struct B307_extra_size {
char a[sizeof(B307)+1];
char b;
};
struct B307_extra_size var672;
#pragma pack(4)
typedef union {
char c:2;
long d:1 __attribute__((packed));
char e:1;
} B308;
B308 var673;
#pragma pack()
struct B308_extra_alignment {
char a;
B308 b;
};
struct B308_extra_alignment var674;
#pragma pack(1)
struct B308_extra_packed {
B308 a;
};
#pragma pack()
struct B308_extra_required_alignment {
char a;
struct B308_extra_packed b;
};
struct B308_extra_required_alignment var675;
struct B308_extra_size {
char a[sizeof(B308)+1];
char b;
};
struct B308_extra_size var676;
#pragma pack(8)
typedef union {
char c:2;
long d:1 __attribute__((packed));
char e:1;
} B309;
B309 var677;
#pragma pack()
struct B309_extra_alignment {
char a;
B309 b;
};
struct B309_extra_alignment var678;
#pragma pack(1)
struct B309_extra_packed {
B309 a;
};
#pragma pack()
struct B309_extra_required_alignment {
char a;
struct B309_extra_packed b;
};
struct B309_extra_required_alignment var679;
struct B309_extra_size {
char a[sizeof(B309)+1];
char b;
};
struct B309_extra_size var680;
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1;
char e:1;
} B310;
B310 var681;
struct B310_extra_alignment {
char a;
B310 b;
};
struct B310_extra_alignment var682;
#pragma pack(1)
struct B310_extra_packed {
B310 a;
};
#pragma pack()
struct B310_extra_required_alignment {
char a;
struct B310_extra_packed b;
};
struct B310_extra_required_alignment var683;
struct B310_extra_size {
char a[sizeof(B310)+1];
char b;
};
struct B310_extra_size var684;
#pragma pack(1)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1;
char e:1;
} B311;
B311 var685;
#pragma pack()
struct B311_extra_alignment {
char a;
B311 b;
};
struct B311_extra_alignment var686;
#pragma pack(1)
struct B311_extra_packed {
B311 a;
};
#pragma pack()
struct B311_extra_required_alignment {
char a;
struct B311_extra_packed b;
};
struct B311_extra_required_alignment var687;
struct B311_extra_size {
char a[sizeof(B311)+1];
char b;
};
struct B311_extra_size var688;
#pragma pack(2)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1;
char e:1;
} B312;
B312 var689;
#pragma pack()
struct B312_extra_alignment {
char a;
B312 b;
};
struct B312_extra_alignment var690;
#pragma pack(1)
struct B312_extra_packed {
B312 a;
};
#pragma pack()
struct B312_extra_required_alignment {
char a;
struct B312_extra_packed b;
};
struct B312_extra_required_alignment var691;
struct B312_extra_size {
char a[sizeof(B312)+1];
char b;
};
struct B312_extra_size var692;
#pragma pack(4)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1;
char e:1;
} B313;
B313 var693;
#pragma pack()
struct B313_extra_alignment {
char a;
B313 b;
};
struct B313_extra_alignment var694;
#pragma pack(1)
struct B313_extra_packed {
B313 a;
};
#pragma pack()
struct B313_extra_required_alignment {
char a;
struct B313_extra_packed b;
};
struct B313_extra_required_alignment var695;
struct B313_extra_size {
char a[sizeof(B313)+1];
char b;
};
struct B313_extra_size var696;
#pragma pack(8)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1;
char e:1;
} B314;
B314 var697;
#pragma pack()
struct B314_extra_alignment {
char a;
B314 b;
};
struct B314_extra_alignment var698;
#pragma pack(1)
struct B314_extra_packed {
B314 a;
};
#pragma pack()
struct B314_extra_required_alignment {
char a;
struct B314_extra_packed b;
};
struct B314_extra_required_alignment var699;
struct B314_extra_size {
char a[sizeof(B314)+1];
char b;
};
struct B314_extra_size var700;
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((packed));
char e:1;
} B315;
B315 var701;
struct B315_extra_alignment {
char a;
B315 b;
};
struct B315_extra_alignment var702;
#pragma pack(1)
struct B315_extra_packed {
B315 a;
};
#pragma pack()
struct B315_extra_required_alignment {
char a;
struct B315_extra_packed b;
};
struct B315_extra_required_alignment var703;
struct B315_extra_size {
char a[sizeof(B315)+1];
char b;
};
struct B315_extra_size var704;
#pragma pack(1)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((packed));
char e:1;
} B316;
B316 var705;
#pragma pack()
struct B316_extra_alignment {
char a;
B316 b;
};
struct B316_extra_alignment var706;
#pragma pack(1)
struct B316_extra_packed {
B316 a;
};
#pragma pack()
struct B316_extra_required_alignment {
char a;
struct B316_extra_packed b;
};
struct B316_extra_required_alignment var707;
struct B316_extra_size {
char a[sizeof(B316)+1];
char b;
};
struct B316_extra_size var708;
#pragma pack(2)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((packed));
char e:1;
} B317;
B317 var709;
#pragma pack()
struct B317_extra_alignment {
char a;
B317 b;
};
struct B317_extra_alignment var710;
#pragma pack(1)
struct B317_extra_packed {
B317 a;
};
#pragma pack()
struct B317_extra_required_alignment {
char a;
struct B317_extra_packed b;
};
struct B317_extra_required_alignment var711;
struct B317_extra_size {
char a[sizeof(B317)+1];
char b;
};
struct B317_extra_size var712;
#pragma pack(4)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((packed));
char e:1;
} B318;
B318 var713;
#pragma pack()
struct B318_extra_alignment {
char a;
B318 b;
};
struct B318_extra_alignment var714;
#pragma pack(1)
struct B318_extra_packed {
B318 a;
};
#pragma pack()
struct B318_extra_required_alignment {
char a;
struct B318_extra_packed b;
};
struct B318_extra_required_alignment var715;
struct B318_extra_size {
char a[sizeof(B318)+1];
char b;
};
struct B318_extra_size var716;
#pragma pack(8)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 1 __attribute__((packed));
char e:1;
} B319;
B319 var717;
#pragma pack()
struct B319_extra_alignment {
char a;
B319 b;
};
struct B319_extra_alignment var718;
#pragma pack(1)
struct B319_extra_packed {
B319 a;
};
#pragma pack()
struct B319_extra_required_alignment {
char a;
struct B319_extra_packed b;
};
struct B319_extra_required_alignment var719;
struct B319_extra_size {
char a[sizeof(B319)+1];
char b;
};
struct B319_extra_size var720;
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(2)));
char e:1;
} B410;
B410 var721;
struct B410_extra_alignment {
char a;
B410 b;
};
struct B410_extra_alignment var722;
#pragma pack(1)
struct B410_extra_packed {
B410 a;
};
#pragma pack()
struct B410_extra_required_alignment {
char a;
struct B410_extra_packed b;
};
struct B410_extra_required_alignment var723;
struct B410_extra_size {
char a[sizeof(B410)+1];
char b;
};
struct B410_extra_size var724;
#pragma pack(1)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(2)));
char e:1;
} B411;
B411 var725;
#pragma pack()
struct B411_extra_alignment {
char a;
B411 b;
};
struct B411_extra_alignment var726;
#pragma pack(1)
struct B411_extra_packed {
B411 a;
};
#pragma pack()
struct B411_extra_required_alignment {
char a;
struct B411_extra_packed b;
};
struct B411_extra_required_alignment var727;
struct B411_extra_size {
char a[sizeof(B411)+1];
char b;
};
struct B411_extra_size var728;
#pragma pack(2)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4)));
char e:1;
} B412;
B412 var729;
#pragma pack()
struct B412_extra_alignment {
char a;
B412 b;
};
struct B412_extra_alignment var730;
#pragma pack(1)
struct B412_extra_packed {
B412 a;
};
#pragma pack()
struct B412_extra_required_alignment {
char a;
struct B412_extra_packed b;
};
struct B412_extra_required_alignment var731;
struct B412_extra_size {
char a[sizeof(B412)+1];
char b;
};
struct B412_extra_size var732;
#pragma pack(4)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4)));
char e:1;
} B413;
B413 var733;
#pragma pack()
struct B413_extra_alignment {
char a;
B413 b;
};
struct B413_extra_alignment var734;
#pragma pack(1)
struct B413_extra_packed {
B413 a;
};
#pragma pack()
struct B413_extra_required_alignment {
char a;
struct B413_extra_packed b;
};
struct B413_extra_required_alignment var735;
struct B413_extra_size {
char a[sizeof(B413)+1];
char b;
};
struct B413_extra_size var736;
#pragma pack(8)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4)));
char e:1;
} B414;
B414 var737;
#pragma pack()
struct B414_extra_alignment {
char a;
B414 b;
};
struct B414_extra_alignment var738;
#pragma pack(1)
struct B414_extra_packed {
B414 a;
};
#pragma pack()
struct B414_extra_required_alignment {
char a;
struct B414_extra_packed b;
};
struct B414_extra_required_alignment var739;
struct B414_extra_size {
char a[sizeof(B414)+1];
char b;
};
struct B414_extra_size var740;
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} B415;
B415 var741;
struct B415_extra_alignment {
char a;
B415 b;
};
struct B415_extra_alignment var742;
#pragma pack(1)
struct B415_extra_packed {
B415 a;
};
#pragma pack()
struct B415_extra_required_alignment {
char a;
struct B415_extra_packed b;
};
struct B415_extra_required_alignment var743;
struct B415_extra_size {
char a[sizeof(B415)+1];
char b;
};
struct B415_extra_size var744;
#pragma pack(1)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(2))) __attribute__((packed));
char e:1;
} B416;
B416 var745;
#pragma pack()
struct B416_extra_alignment {
char a;
B416 b;
};
struct B416_extra_alignment var746;
#pragma pack(1)
struct B416_extra_packed {
B416 a;
};
#pragma pack()
struct B416_extra_required_alignment {
char a;
struct B416_extra_packed b;
};
struct B416_extra_required_alignment var747;
struct B416_extra_size {
char a[sizeof(B416)+1];
char b;
};
struct B416_extra_size var748;
#pragma pack(2)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B417;
B417 var749;
#pragma pack()
struct B417_extra_alignment {
char a;
B417 b;
};
struct B417_extra_alignment var750;
#pragma pack(1)
struct B417_extra_packed {
B417 a;
};
#pragma pack()
struct B417_extra_required_alignment {
char a;
struct B417_extra_packed b;
};
struct B417_extra_required_alignment var751;
struct B417_extra_size {
char a[sizeof(B417)+1];
char b;
};
struct B417_extra_size var752;
#pragma pack(4)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B418;
B418 var753;
#pragma pack()
struct B418_extra_alignment {
char a;
B418 b;
};
struct B418_extra_alignment var754;
#pragma pack(1)
struct B418_extra_packed {
B418 a;
};
#pragma pack()
struct B418_extra_required_alignment {
char a;
struct B418_extra_packed b;
};
struct B418_extra_required_alignment var755;
struct B418_extra_size {
char a[sizeof(B418)+1];
char b;
};
struct B418_extra_size var756;
#pragma pack(8)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((aligned(4))) __attribute__((packed));
char e:1;
} B419;
B419 var757;
#pragma pack()
struct B419_extra_alignment {
char a;
B419 b;
};
struct B419_extra_alignment var758;
#pragma pack(1)
struct B419_extra_packed {
B419 a;
};
#pragma pack()
struct B419_extra_required_alignment {
char a;
struct B419_extra_packed b;
};
struct B419_extra_required_alignment var759;
struct B419_extra_size {
char a[sizeof(B419)+1];
char b;
};
struct B419_extra_size var760;
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2;
char e:1;
} B510;
B510 var761;
struct B510_extra_alignment {
char a;
B510 b;
};
struct B510_extra_alignment var762;
#pragma pack(1)
struct B510_extra_packed {
B510 a;
};
#pragma pack()
struct B510_extra_required_alignment {
char a;
struct B510_extra_packed b;
};
struct B510_extra_required_alignment var763;
struct B510_extra_size {
char a[sizeof(B510)+1];
char b;
};
struct B510_extra_size var764;
#pragma pack(1)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2;
char e:1;
} B511;
B511 var765;
#pragma pack()
struct B511_extra_alignment {
char a;
B511 b;
};
struct B511_extra_alignment var766;
#pragma pack(1)
struct B511_extra_packed {
B511 a;
};
#pragma pack()
struct B511_extra_required_alignment {
char a;
struct B511_extra_packed b;
};
struct B511_extra_required_alignment var767;
struct B511_extra_size {
char a[sizeof(B511)+1];
char b;
};
struct B511_extra_size var768;
#pragma pack(2)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2;
char e:1;
} B512;
B512 var769;
#pragma pack()
struct B512_extra_alignment {
char a;
B512 b;
};
struct B512_extra_alignment var770;
#pragma pack(1)
struct B512_extra_packed {
B512 a;
};
#pragma pack()
struct B512_extra_required_alignment {
char a;
struct B512_extra_packed b;
};
struct B512_extra_required_alignment var771;
struct B512_extra_size {
char a[sizeof(B512)+1];
char b;
};
struct B512_extra_size var772;
#pragma pack(4)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2;
char e:1;
} B513;
B513 var773;
#pragma pack()
struct B513_extra_alignment {
char a;
B513 b;
};
struct B513_extra_alignment var774;
#pragma pack(1)
struct B513_extra_packed {
B513 a;
};
#pragma pack()
struct B513_extra_required_alignment {
char a;
struct B513_extra_packed b;
};
struct B513_extra_required_alignment var775;
struct B513_extra_size {
char a[sizeof(B513)+1];
char b;
};
struct B513_extra_size var776;
#pragma pack(8)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2;
char e:1;
} B514;
B514 var777;
#pragma pack()
struct B514_extra_alignment {
char a;
B514 b;
};
struct B514_extra_alignment var778;
#pragma pack(1)
struct B514_extra_packed {
B514 a;
};
#pragma pack()
struct B514_extra_required_alignment {
char a;
struct B514_extra_packed b;
};
struct B514_extra_required_alignment var779;
struct B514_extra_size {
char a[sizeof(B514)+1];
char b;
};
struct B514_extra_size var780;
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((packed));
char e:1;
} B515;
B515 var781;
struct B515_extra_alignment {
char a;
B515 b;
};
struct B515_extra_alignment var782;
#pragma pack(1)
struct B515_extra_packed {
B515 a;
};
#pragma pack()
struct B515_extra_required_alignment {
char a;
struct B515_extra_packed b;
};
struct B515_extra_required_alignment var783;
struct B515_extra_size {
char a[sizeof(B515)+1];
char b;
};
struct B515_extra_size var784;
#pragma pack(1)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((packed));
char e:1;
} B516;
B516 var785;
#pragma pack()
struct B516_extra_alignment {
char a;
B516 b;
};
struct B516_extra_alignment var786;
#pragma pack(1)
struct B516_extra_packed {
B516 a;
};
#pragma pack()
struct B516_extra_required_alignment {
char a;
struct B516_extra_packed b;
};
struct B516_extra_required_alignment var787;
struct B516_extra_size {
char a[sizeof(B516)+1];
char b;
};
struct B516_extra_size var788;
#pragma pack(2)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((packed));
char e:1;
} B517;
B517 var789;
#pragma pack()
struct B517_extra_alignment {
char a;
B517 b;
};
struct B517_extra_alignment var790;
#pragma pack(1)
struct B517_extra_packed {
B517 a;
};
#pragma pack()
struct B517_extra_required_alignment {
char a;
struct B517_extra_packed b;
};
struct B517_extra_required_alignment var791;
struct B517_extra_size {
char a[sizeof(B517)+1];
char b;
};
struct B517_extra_size var792;
#pragma pack(4)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((packed));
char e:1;
} B518;
B518 var793;
#pragma pack()
struct B518_extra_alignment {
char a;
B518 b;
};
struct B518_extra_alignment var794;
#pragma pack(1)
struct B518_extra_packed {
B518 a;
};
#pragma pack()
struct B518_extra_required_alignment {
char a;
struct B518_extra_packed b;
};
struct B518_extra_required_alignment var795;
struct B518_extra_size {
char a[sizeof(B518)+1];
char b;
};
struct B518_extra_size var796;
#pragma pack(8)
typedef union {
char c:2;
long d:(sizeof(long)*8) - 2 __attribute__((packed));
char e:1;
} B519;
B519 var797;
#pragma pack()
struct B519_extra_alignment {
char a;
B519 b;
};
struct B519_extra_alignment var798;
#pragma pack(1)
struct B519_extra_packed {
B519 a;
};
#pragma pack()
struct B519_extra_required_alignment {
char a;
struct B519_extra_packed b;
};
struct B519_extra_required_alignment var799;
struct B519_extra_size {
char a[sizeof(B519)+1];
char b;
};
struct B519_extra_size var800;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|powerpc64-ppc64-freebsd-gnu:Clang|riscv64-baseline_rv64-other-eabi:Clang|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A000) == 4, "");
_Static_assert(_Alignof(A000) == 2, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 6, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A000,e) == 17, "");
#endif
_Static_assert(sizeof(A001) == 1, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 3, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A001,e) == 2, "");
#endif
_Static_assert(sizeof(A002) == 2, "");
_Static_assert(_Alignof(A002) == 2, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 4, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A002,e) == 2, "");
#endif
_Static_assert(sizeof(A003) == 8, "");
_Static_assert(_Alignof(A003) == 4, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A003_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 10, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A003,e) == 33, "");
#endif
_Static_assert(sizeof(A004) == 8, "");
_Static_assert(_Alignof(A004) == 4, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A004_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 10, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A004,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A004,e) == 33, "");
#endif
_Static_assert(sizeof(A005) == 4, "");
_Static_assert(_Alignof(A005) == 2, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A005_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 6, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A005,e) == 17, "");
#endif
_Static_assert(sizeof(A006) == 1, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 3, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A006,e) == 2, "");
#endif
_Static_assert(sizeof(A007) == 2, "");
_Static_assert(_Alignof(A007) == 2, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 4, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A007,e) == 2, "");
#endif
_Static_assert(sizeof(A008) == 8, "");
_Static_assert(_Alignof(A008) == 4, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A008_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 10, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A008,e) == 33, "");
#endif
_Static_assert(sizeof(A009) == 8, "");
_Static_assert(_Alignof(A009) == 4, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A009_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 10, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A009,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A009,e) == 33, "");
#endif
_Static_assert(sizeof(A010) == 4, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 6, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A010,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A010,e) == 24, "");
#endif
_Static_assert(sizeof(A011) == 2, "");
_Static_assert(_Alignof(A011) == 1, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 4, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A011,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A011,e) == 9, "");
#endif
_Static_assert(sizeof(A012) == 2, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 4, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A012,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A012,e) == 9, "");
#endif
_Static_assert(sizeof(A013) == 8, "");
_Static_assert(_Alignof(A013) == 4, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A013_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 10, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A013,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A013,e) == 40, "");
#endif
_Static_assert(sizeof(A014) == 8, "");
_Static_assert(_Alignof(A014) == 4, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A014_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 10, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A014,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A014,e) == 40, "");
#endif
_Static_assert(sizeof(A015) == 4, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 6, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A015,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A015,e) == 24, "");
#endif
_Static_assert(sizeof(A016) == 2, "");
_Static_assert(_Alignof(A016) == 1, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 4, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A016,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A016,e) == 9, "");
#endif
_Static_assert(sizeof(A017) == 2, "");
_Static_assert(_Alignof(A017) == 2, "");
_Static_assert(sizeof(struct A017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A017_extra_packed) == 1, "");
_Static_assert(sizeof(struct A017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A017_extra_size) == 4, "");
_Static_assert(_Alignof(struct A017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A017,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A017,e) == 9, "");
#endif
_Static_assert(sizeof(A018) == 8, "");
_Static_assert(_Alignof(A018) == 4, "");
_Static_assert(sizeof(struct A018_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A018_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A018_extra_packed) == 1, "");
_Static_assert(sizeof(struct A018_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A018_extra_size) == 10, "");
_Static_assert(_Alignof(struct A018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A018,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A018,e) == 40, "");
#endif
_Static_assert(sizeof(A019) == 8, "");
_Static_assert(_Alignof(A019) == 4, "");
_Static_assert(sizeof(struct A019_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A019_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A019_extra_packed) == 1, "");
_Static_assert(sizeof(struct A019_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A019_extra_size) == 10, "");
_Static_assert(_Alignof(struct A019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A019,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A019,e) == 40, "");
#endif
_Static_assert(sizeof(A100) == 8, "");
_Static_assert(_Alignof(A100) == 8, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A100_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 10, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A100,e) == 17, "");
#endif
_Static_assert(sizeof(A101) == 1, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 3, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A101,e) == 3, "");
#endif
_Static_assert(sizeof(A102) == 2, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 4, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A102,e) == 3, "");
#endif
_Static_assert(sizeof(A103) == 8, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 10, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A103,e) == 33, "");
#endif
_Static_assert(sizeof(A104) == 8, "");
_Static_assert(_Alignof(A104) == 8, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A104_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 10, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A104,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A104,e) == 33, "");
#endif
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A105,e) == 17, "");
#endif
_Static_assert(sizeof(A106) == 1, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 3, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A106,e) == 3, "");
#endif
_Static_assert(sizeof(A107) == 2, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 4, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A107,e) == 3, "");
#endif
_Static_assert(sizeof(A108) == 8, "");
_Static_assert(_Alignof(A108) == 4, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A108_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 10, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A108,e) == 33, "");
#endif
_Static_assert(sizeof(A109) == 8, "");
_Static_assert(_Alignof(A109) == 8, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A109_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 10, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A109,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A109,e) == 33, "");
#endif
_Static_assert(sizeof(A110) == 16, "");
_Static_assert(_Alignof(A110) == 8, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A110_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 18, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A110,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(A110,e) == 127, "");
#endif
_Static_assert(sizeof(A111) == 9, "");
_Static_assert(_Alignof(A111) == 1, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 11, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A111,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A111,e) == 65, "");
#endif
_Static_assert(sizeof(A112) == 10, "");
_Static_assert(_Alignof(A112) == 2, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A112_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 12, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A112,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A112,e) == 65, "");
#endif
_Static_assert(sizeof(A113) == 12, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 14, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A113,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A113,e) == 95, "");
#endif
_Static_assert(sizeof(A114) == 16, "");
_Static_assert(_Alignof(A114) == 8, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A114_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 18, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A114,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A114,e) == 95, "");
#endif
_Static_assert(sizeof(A115) == 10, "");
_Static_assert(_Alignof(A115) == 2, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A115_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 12, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A115,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A115,e) == 79, "");
#endif
_Static_assert(sizeof(A116) == 9, "");
_Static_assert(_Alignof(A116) == 1, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 11, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A116,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A116,e) == 65, "");
#endif
_Static_assert(sizeof(A117) == 10, "");
_Static_assert(_Alignof(A117) == 2, "");
_Static_assert(sizeof(struct A117_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A117_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A117_extra_packed) == 1, "");
_Static_assert(sizeof(struct A117_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A117_extra_size) == 12, "");
_Static_assert(_Alignof(struct A117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A117,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A117,e) == 65, "");
#endif
_Static_assert(sizeof(A118) == 12, "");
_Static_assert(_Alignof(A118) == 4, "");
_Static_assert(sizeof(struct A118_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A118_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A118_extra_packed) == 1, "");
_Static_assert(sizeof(struct A118_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A118_extra_size) == 14, "");
_Static_assert(_Alignof(struct A118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A118,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A118,e) == 95, "");
#endif
_Static_assert(sizeof(A119) == 16, "");
_Static_assert(_Alignof(A119) == 8, "");
_Static_assert(sizeof(struct A119_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A119_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A119_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A119_extra_packed) == 1, "");
_Static_assert(sizeof(struct A119_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A119_extra_size) == 18, "");
_Static_assert(_Alignof(struct A119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A119,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A119,e) == 95, "");
#endif
_Static_assert(sizeof(A200) == 1, "");
_Static_assert(_Alignof(A200) == 1, "");
_Static_assert(sizeof(struct A200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A200_extra_packed) == 1, "");
_Static_assert(sizeof(struct A200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_size) == 3, "");
_Static_assert(_Alignof(struct A200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A200,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A200,e) == 2, "");
#endif
_Static_assert(sizeof(A201) == 1, "");
_Static_assert(_Alignof(A201) == 1, "");
_Static_assert(sizeof(struct A201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A201_extra_packed) == 1, "");
_Static_assert(sizeof(struct A201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_size) == 3, "");
_Static_assert(_Alignof(struct A201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A201,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A201,e) == 2, "");
#endif
_Static_assert(sizeof(A202) == 1, "");
_Static_assert(_Alignof(A202) == 1, "");
_Static_assert(sizeof(struct A202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A202_extra_packed) == 1, "");
_Static_assert(sizeof(struct A202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_size) == 3, "");
_Static_assert(_Alignof(struct A202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A202,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A202,e) == 2, "");
#endif
_Static_assert(sizeof(A203) == 1, "");
_Static_assert(_Alignof(A203) == 1, "");
_Static_assert(sizeof(struct A203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A203_extra_packed) == 1, "");
_Static_assert(sizeof(struct A203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_size) == 3, "");
_Static_assert(_Alignof(struct A203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A203,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A203,e) == 2, "");
#endif
_Static_assert(sizeof(A204) == 1, "");
_Static_assert(_Alignof(A204) == 1, "");
_Static_assert(sizeof(struct A204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A204_extra_packed) == 1, "");
_Static_assert(sizeof(struct A204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_size) == 3, "");
_Static_assert(_Alignof(struct A204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A204,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A204,e) == 2, "");
#endif
_Static_assert(sizeof(A205) == 1, "");
_Static_assert(_Alignof(A205) == 1, "");
_Static_assert(sizeof(struct A205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A205_extra_packed) == 1, "");
_Static_assert(sizeof(struct A205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_size) == 3, "");
_Static_assert(_Alignof(struct A205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A205,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A205,e) == 2, "");
#endif
_Static_assert(sizeof(A206) == 1, "");
_Static_assert(_Alignof(A206) == 1, "");
_Static_assert(sizeof(struct A206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A206_extra_packed) == 1, "");
_Static_assert(sizeof(struct A206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_size) == 3, "");
_Static_assert(_Alignof(struct A206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A206,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A206,e) == 2, "");
#endif
_Static_assert(sizeof(A207) == 1, "");
_Static_assert(_Alignof(A207) == 1, "");
_Static_assert(sizeof(struct A207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A207_extra_packed) == 1, "");
_Static_assert(sizeof(struct A207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_size) == 3, "");
_Static_assert(_Alignof(struct A207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A207,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A207,e) == 2, "");
#endif
_Static_assert(sizeof(A208) == 1, "");
_Static_assert(_Alignof(A208) == 1, "");
_Static_assert(sizeof(struct A208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A208_extra_packed) == 1, "");
_Static_assert(sizeof(struct A208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_size) == 3, "");
_Static_assert(_Alignof(struct A208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A208,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A208,e) == 2, "");
#endif
_Static_assert(sizeof(A209) == 1, "");
_Static_assert(_Alignof(A209) == 1, "");
_Static_assert(sizeof(struct A209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A209_extra_packed) == 1, "");
_Static_assert(sizeof(struct A209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_size) == 3, "");
_Static_assert(_Alignof(struct A209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A209,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A209,e) == 2, "");
#endif
_Static_assert(sizeof(A210) == 3, "");
_Static_assert(_Alignof(A210) == 1, "");
_Static_assert(sizeof(struct A210_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A210_extra_packed) == 1, "");
_Static_assert(sizeof(struct A210_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_size) == 5, "");
_Static_assert(_Alignof(struct A210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A210,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A210,e) == 16, "");
#endif
_Static_assert(sizeof(A211) == 2, "");
_Static_assert(_Alignof(A211) == 1, "");
_Static_assert(sizeof(struct A211_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A211_extra_packed) == 1, "");
_Static_assert(sizeof(struct A211_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_size) == 4, "");
_Static_assert(_Alignof(struct A211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A211,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A211,e) == 9, "");
#endif
_Static_assert(sizeof(A212) == 2, "");
_Static_assert(_Alignof(A212) == 1, "");
_Static_assert(sizeof(struct A212_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A212_extra_packed) == 1, "");
_Static_assert(sizeof(struct A212_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_size) == 4, "");
_Static_assert(_Alignof(struct A212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A212,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A212,e) == 9, "");
#endif
_Static_assert(sizeof(A213) == 2, "");
_Static_assert(_Alignof(A213) == 1, "");
_Static_assert(sizeof(struct A213_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A213_extra_packed) == 1, "");
_Static_assert(sizeof(struct A213_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_size) == 4, "");
_Static_assert(_Alignof(struct A213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A213,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A213,e) == 9, "");
#endif
_Static_assert(sizeof(A214) == 2, "");
_Static_assert(_Alignof(A214) == 1, "");
_Static_assert(sizeof(struct A214_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A214_extra_packed) == 1, "");
_Static_assert(sizeof(struct A214_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_size) == 4, "");
_Static_assert(_Alignof(struct A214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A214,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A214,e) == 9, "");
#endif
_Static_assert(sizeof(A215) == 2, "");
_Static_assert(_Alignof(A215) == 1, "");
_Static_assert(sizeof(struct A215_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A215_extra_packed) == 1, "");
_Static_assert(sizeof(struct A215_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_size) == 4, "");
_Static_assert(_Alignof(struct A215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A215,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A215,e) == 9, "");
#endif
_Static_assert(sizeof(A216) == 2, "");
_Static_assert(_Alignof(A216) == 1, "");
_Static_assert(sizeof(struct A216_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A216_extra_packed) == 1, "");
_Static_assert(sizeof(struct A216_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_size) == 4, "");
_Static_assert(_Alignof(struct A216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A216,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A216,e) == 9, "");
#endif
_Static_assert(sizeof(A217) == 2, "");
_Static_assert(_Alignof(A217) == 1, "");
_Static_assert(sizeof(struct A217_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A217_extra_packed) == 1, "");
_Static_assert(sizeof(struct A217_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_size) == 4, "");
_Static_assert(_Alignof(struct A217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A217,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A217,e) == 9, "");
#endif
_Static_assert(sizeof(A218) == 2, "");
_Static_assert(_Alignof(A218) == 1, "");
_Static_assert(sizeof(struct A218_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A218_extra_packed) == 1, "");
_Static_assert(sizeof(struct A218_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_size) == 4, "");
_Static_assert(_Alignof(struct A218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A218,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A218,e) == 9, "");
#endif
_Static_assert(sizeof(A219) == 2, "");
_Static_assert(_Alignof(A219) == 1, "");
_Static_assert(sizeof(struct A219_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A219_extra_packed) == 1, "");
_Static_assert(sizeof(struct A219_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_size) == 4, "");
_Static_assert(_Alignof(struct A219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A219,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A219,e) == 9, "");
#endif
_Static_assert(sizeof(A300) == 8, "");
_Static_assert(_Alignof(A300) == 8, "");
_Static_assert(sizeof(struct A300_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A300_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A300_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A300_extra_packed) == 1, "");
_Static_assert(sizeof(struct A300_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A300_extra_size) == 10, "");
_Static_assert(_Alignof(struct A300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A300,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A300,e) == 3, "");
#endif
_Static_assert(sizeof(A301) == 1, "");
_Static_assert(_Alignof(A301) == 1, "");
_Static_assert(sizeof(struct A301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A301_extra_packed) == 1, "");
_Static_assert(sizeof(struct A301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_size) == 3, "");
_Static_assert(_Alignof(struct A301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A301,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A301,e) == 3, "");
#endif
_Static_assert(sizeof(A302) == 2, "");
_Static_assert(_Alignof(A302) == 2, "");
_Static_assert(sizeof(struct A302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A302_extra_packed) == 1, "");
_Static_assert(sizeof(struct A302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A302_extra_size) == 4, "");
_Static_assert(_Alignof(struct A302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A302,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A302,e) == 3, "");
#endif
_Static_assert(sizeof(A303) == 4, "");
_Static_assert(_Alignof(A303) == 4, "");
_Static_assert(sizeof(struct A303_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A303_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A303_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A303_extra_packed) == 1, "");
_Static_assert(sizeof(struct A303_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A303_extra_size) == 6, "");
_Static_assert(_Alignof(struct A303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A303,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A303,e) == 3, "");
#endif
_Static_assert(sizeof(A304) == 8, "");
_Static_assert(_Alignof(A304) == 8, "");
_Static_assert(sizeof(struct A304_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A304_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A304_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A304_extra_packed) == 1, "");
_Static_assert(sizeof(struct A304_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A304_extra_size) == 10, "");
_Static_assert(_Alignof(struct A304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A304,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A304,e) == 3, "");
#endif
_Static_assert(sizeof(A305) == 1, "");
_Static_assert(_Alignof(A305) == 1, "");
_Static_assert(sizeof(struct A305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A305_extra_packed) == 1, "");
_Static_assert(sizeof(struct A305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_size) == 3, "");
_Static_assert(_Alignof(struct A305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A305,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A305,e) == 3, "");
#endif
_Static_assert(sizeof(A306) == 1, "");
_Static_assert(_Alignof(A306) == 1, "");
_Static_assert(sizeof(struct A306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A306_extra_packed) == 1, "");
_Static_assert(sizeof(struct A306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_size) == 3, "");
_Static_assert(_Alignof(struct A306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A306,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A306,e) == 3, "");
#endif
_Static_assert(sizeof(A307) == 2, "");
_Static_assert(_Alignof(A307) == 2, "");
_Static_assert(sizeof(struct A307_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A307_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A307_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A307_extra_packed) == 1, "");
_Static_assert(sizeof(struct A307_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_size) == 4, "");
_Static_assert(_Alignof(struct A307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A307,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A307,e) == 3, "");
#endif
_Static_assert(sizeof(A308) == 4, "");
_Static_assert(_Alignof(A308) == 4, "");
_Static_assert(sizeof(struct A308_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A308_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A308_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A308_extra_packed) == 1, "");
_Static_assert(sizeof(struct A308_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_size) == 6, "");
_Static_assert(_Alignof(struct A308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A308,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A308,e) == 3, "");
#endif
_Static_assert(sizeof(A309) == 8, "");
_Static_assert(_Alignof(A309) == 8, "");
_Static_assert(sizeof(struct A309_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A309_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A309_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A309_extra_packed) == 1, "");
_Static_assert(sizeof(struct A309_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_size) == 10, "");
_Static_assert(_Alignof(struct A309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A309,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A309,e) == 3, "");
#endif
_Static_assert(sizeof(A310) == 16, "");
_Static_assert(_Alignof(A310) == 8, "");
_Static_assert(sizeof(struct A310_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A310_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A310_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A310_extra_packed) == 1, "");
_Static_assert(sizeof(struct A310_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A310_extra_size) == 18, "");
_Static_assert(_Alignof(struct A310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A310,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(A310,e) == 127, "");
#endif
_Static_assert(sizeof(A311) == 9, "");
_Static_assert(_Alignof(A311) == 1, "");
_Static_assert(sizeof(struct A311_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A311_extra_packed) == 1, "");
_Static_assert(sizeof(struct A311_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_size) == 11, "");
_Static_assert(_Alignof(struct A311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A311,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A311,e) == 65, "");
#endif
_Static_assert(sizeof(A312) == 10, "");
_Static_assert(_Alignof(A312) == 2, "");
_Static_assert(sizeof(struct A312_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A312_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A312_extra_packed) == 1, "");
_Static_assert(sizeof(struct A312_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A312_extra_size) == 12, "");
_Static_assert(_Alignof(struct A312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A312,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A312,e) == 65, "");
#endif
_Static_assert(sizeof(A313) == 12, "");
_Static_assert(_Alignof(A313) == 4, "");
_Static_assert(sizeof(struct A313_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A313_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A313_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A313_extra_packed) == 1, "");
_Static_assert(sizeof(struct A313_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A313_extra_size) == 14, "");
_Static_assert(_Alignof(struct A313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A313,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A313,e) == 65, "");
#endif
_Static_assert(sizeof(A314) == 16, "");
_Static_assert(_Alignof(A314) == 8, "");
_Static_assert(sizeof(struct A314_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A314_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A314_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A314_extra_packed) == 1, "");
_Static_assert(sizeof(struct A314_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A314_extra_size) == 18, "");
_Static_assert(_Alignof(struct A314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A314,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A314,e) == 65, "");
#endif
_Static_assert(sizeof(A315) == 9, "");
_Static_assert(_Alignof(A315) == 1, "");
_Static_assert(sizeof(struct A315_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A315_extra_packed) == 1, "");
_Static_assert(sizeof(struct A315_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_size) == 11, "");
_Static_assert(_Alignof(struct A315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A315,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A315,e) == 65, "");
#endif
_Static_assert(sizeof(A316) == 9, "");
_Static_assert(_Alignof(A316) == 1, "");
_Static_assert(sizeof(struct A316_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A316_extra_packed) == 1, "");
_Static_assert(sizeof(struct A316_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_size) == 11, "");
_Static_assert(_Alignof(struct A316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A316,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A316,e) == 65, "");
#endif
_Static_assert(sizeof(A317) == 10, "");
_Static_assert(_Alignof(A317) == 2, "");
_Static_assert(sizeof(struct A317_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A317_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A317_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A317_extra_packed) == 1, "");
_Static_assert(sizeof(struct A317_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_size) == 12, "");
_Static_assert(_Alignof(struct A317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A317,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A317,e) == 65, "");
#endif
_Static_assert(sizeof(A318) == 12, "");
_Static_assert(_Alignof(A318) == 4, "");
_Static_assert(sizeof(struct A318_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A318_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A318_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A318_extra_packed) == 1, "");
_Static_assert(sizeof(struct A318_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_size) == 14, "");
_Static_assert(_Alignof(struct A318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A318,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A318,e) == 65, "");
#endif
_Static_assert(sizeof(A319) == 16, "");
_Static_assert(_Alignof(A319) == 8, "");
_Static_assert(sizeof(struct A319_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A319_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A319_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A319_extra_packed) == 1, "");
_Static_assert(sizeof(struct A319_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_size) == 18, "");
_Static_assert(_Alignof(struct A319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A319,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A319,e) == 65, "");
#endif
_Static_assert(sizeof(A410) == 16, "");
_Static_assert(_Alignof(A410) == 8, "");
_Static_assert(sizeof(struct A410_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A410_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A410_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A410_extra_packed) == 1, "");
_Static_assert(sizeof(struct A410_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A410_extra_size) == 18, "");
_Static_assert(_Alignof(struct A410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A410,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A410,e) == 78, "");
#endif
_Static_assert(sizeof(A411) == 9, "");
_Static_assert(_Alignof(A411) == 1, "");
_Static_assert(sizeof(struct A411_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A411_extra_packed) == 1, "");
_Static_assert(sizeof(struct A411_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_size) == 11, "");
_Static_assert(_Alignof(struct A411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A411,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A411,e) == 64, "");
#endif
_Static_assert(sizeof(A412) == 10, "");
_Static_assert(_Alignof(A412) == 2, "");
_Static_assert(sizeof(struct A412_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A412_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A412_extra_packed) == 1, "");
_Static_assert(sizeof(struct A412_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A412_extra_size) == 12, "");
_Static_assert(_Alignof(struct A412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A412,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A412,e) == 64, "");
#endif
_Static_assert(sizeof(A413) == 12, "");
_Static_assert(_Alignof(A413) == 4, "");
_Static_assert(sizeof(struct A413_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A413_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A413_extra_packed) == 1, "");
_Static_assert(sizeof(struct A413_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A413_extra_size) == 14, "");
_Static_assert(_Alignof(struct A413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A413,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A413,e) == 94, "");
#endif
_Static_assert(sizeof(A414) == 16, "");
_Static_assert(_Alignof(A414) == 8, "");
_Static_assert(sizeof(struct A414_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A414_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A414_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A414_extra_packed) == 1, "");
_Static_assert(sizeof(struct A414_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A414_extra_size) == 18, "");
_Static_assert(_Alignof(struct A414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A414,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A414,e) == 94, "");
#endif
_Static_assert(sizeof(A415) == 10, "");
_Static_assert(_Alignof(A415) == 2, "");
_Static_assert(sizeof(struct A415_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A415_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A415_extra_packed) == 1, "");
_Static_assert(sizeof(struct A415_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A415_extra_size) == 12, "");
_Static_assert(_Alignof(struct A415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A415,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A415,e) == 78, "");
#endif
_Static_assert(sizeof(A416) == 9, "");
_Static_assert(_Alignof(A416) == 1, "");
_Static_assert(sizeof(struct A416_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A416_extra_packed) == 1, "");
_Static_assert(sizeof(struct A416_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_size) == 11, "");
_Static_assert(_Alignof(struct A416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A416,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A416,e) == 64, "");
#endif
_Static_assert(sizeof(A417) == 10, "");
_Static_assert(_Alignof(A417) == 2, "");
_Static_assert(sizeof(struct A417_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A417_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A417_extra_packed) == 1, "");
_Static_assert(sizeof(struct A417_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A417_extra_size) == 12, "");
_Static_assert(_Alignof(struct A417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A417,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A417,e) == 64, "");
#endif
_Static_assert(sizeof(A418) == 12, "");
_Static_assert(_Alignof(A418) == 4, "");
_Static_assert(sizeof(struct A418_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A418_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A418_extra_packed) == 1, "");
_Static_assert(sizeof(struct A418_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A418_extra_size) == 14, "");
_Static_assert(_Alignof(struct A418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A418,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A418,e) == 94, "");
#endif
_Static_assert(sizeof(A419) == 16, "");
_Static_assert(_Alignof(A419) == 8, "");
_Static_assert(sizeof(struct A419_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A419_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A419_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A419_extra_packed) == 1, "");
_Static_assert(sizeof(struct A419_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A419_extra_size) == 18, "");
_Static_assert(_Alignof(struct A419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A419,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A419,e) == 94, "");
#endif
_Static_assert(sizeof(A510) == 16, "");
_Static_assert(_Alignof(A510) == 8, "");
_Static_assert(sizeof(struct A510_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A510_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A510_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A510_extra_packed) == 1, "");
_Static_assert(sizeof(struct A510_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A510_extra_size) == 18, "");
_Static_assert(_Alignof(struct A510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A510,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A510,e) == 64, "");
#endif
_Static_assert(sizeof(A511) == 9, "");
_Static_assert(_Alignof(A511) == 1, "");
_Static_assert(sizeof(struct A511_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A511_extra_packed) == 1, "");
_Static_assert(sizeof(struct A511_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_size) == 11, "");
_Static_assert(_Alignof(struct A511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A511,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A511,e) == 64, "");
#endif
_Static_assert(sizeof(A512) == 10, "");
_Static_assert(_Alignof(A512) == 2, "");
_Static_assert(sizeof(struct A512_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A512_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A512_extra_packed) == 1, "");
_Static_assert(sizeof(struct A512_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A512_extra_size) == 12, "");
_Static_assert(_Alignof(struct A512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A512,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A512,e) == 64, "");
#endif
_Static_assert(sizeof(A513) == 12, "");
_Static_assert(_Alignof(A513) == 4, "");
_Static_assert(sizeof(struct A513_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A513_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A513_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A513_extra_packed) == 1, "");
_Static_assert(sizeof(struct A513_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A513_extra_size) == 14, "");
_Static_assert(_Alignof(struct A513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A513,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A513,e) == 64, "");
#endif
_Static_assert(sizeof(A514) == 16, "");
_Static_assert(_Alignof(A514) == 8, "");
_Static_assert(sizeof(struct A514_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A514_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A514_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A514_extra_packed) == 1, "");
_Static_assert(sizeof(struct A514_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A514_extra_size) == 18, "");
_Static_assert(_Alignof(struct A514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A514,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A514,e) == 64, "");
#endif
_Static_assert(sizeof(A515) == 9, "");
_Static_assert(_Alignof(A515) == 1, "");
_Static_assert(sizeof(struct A515_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A515_extra_packed) == 1, "");
_Static_assert(sizeof(struct A515_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_size) == 11, "");
_Static_assert(_Alignof(struct A515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A515,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A515,e) == 64, "");
#endif
_Static_assert(sizeof(A516) == 9, "");
_Static_assert(_Alignof(A516) == 1, "");
_Static_assert(sizeof(struct A516_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A516_extra_packed) == 1, "");
_Static_assert(sizeof(struct A516_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_size) == 11, "");
_Static_assert(_Alignof(struct A516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A516,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A516,e) == 64, "");
#endif
_Static_assert(sizeof(A517) == 10, "");
_Static_assert(_Alignof(A517) == 2, "");
_Static_assert(sizeof(struct A517_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A517_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A517_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A517_extra_packed) == 1, "");
_Static_assert(sizeof(struct A517_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_size) == 12, "");
_Static_assert(_Alignof(struct A517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A517,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A517,e) == 64, "");
#endif
_Static_assert(sizeof(A518) == 12, "");
_Static_assert(_Alignof(A518) == 4, "");
_Static_assert(sizeof(struct A518_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A518_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A518_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A518_extra_packed) == 1, "");
_Static_assert(sizeof(struct A518_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_size) == 14, "");
_Static_assert(_Alignof(struct A518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A518,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A518,e) == 64, "");
#endif
_Static_assert(sizeof(A519) == 16, "");
_Static_assert(_Alignof(A519) == 8, "");
_Static_assert(sizeof(struct A519_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A519_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A519_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A519_extra_packed) == 1, "");
_Static_assert(sizeof(struct A519_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_size) == 18, "");
_Static_assert(_Alignof(struct A519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A519,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A519,e) == 64, "");
#endif
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 2, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B000,e) == 0, "");
#endif
_Static_assert(sizeof(B001) == 1, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 3, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B001,e) == 0, "");
#endif
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 2, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B002,e) == 0, "");
#endif
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 4, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B003,e) == 0, "");
#endif
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 4, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B004,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B004,e) == 0, "");
#endif
_Static_assert(sizeof(B005) == 2, "");
_Static_assert(_Alignof(B005) == 2, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B005_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 4, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B005,e) == 0, "");
#endif
_Static_assert(sizeof(B006) == 1, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 3, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B006,e) == 0, "");
#endif
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 2, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B007,e) == 0, "");
#endif
_Static_assert(sizeof(B008) == 4, "");
_Static_assert(_Alignof(B008) == 4, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B008_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 6, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B008,e) == 0, "");
#endif
_Static_assert(sizeof(B009) == 4, "");
_Static_assert(_Alignof(B009) == 4, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B009_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 6, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B009,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B009,e) == 0, "");
#endif
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 2, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B010,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B010,e) == 0, "");
#endif
_Static_assert(sizeof(B011) == 1, "");
_Static_assert(_Alignof(B011) == 1, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 3, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B011,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B011,e) == 0, "");
#endif
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 2, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B012,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B012,e) == 0, "");
#endif
_Static_assert(sizeof(B013) == 4, "");
_Static_assert(_Alignof(B013) == 4, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B013_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 6, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B013,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B013,e) == 0, "");
#endif
_Static_assert(sizeof(B014) == 4, "");
_Static_assert(_Alignof(B014) == 4, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B014_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 6, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B014,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B014,e) == 0, "");
#endif
_Static_assert(sizeof(B015) == 2, "");
_Static_assert(_Alignof(B015) == 2, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 4, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B015,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B015,e) == 0, "");
#endif
_Static_assert(sizeof(B016) == 1, "");
_Static_assert(_Alignof(B016) == 1, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 3, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B016,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B016,e) == 0, "");
#endif
_Static_assert(sizeof(B017) == 2, "");
_Static_assert(_Alignof(B017) == 2, "");
_Static_assert(sizeof(struct B017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B017_extra_packed) == 1, "");
_Static_assert(sizeof(struct B017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B017_extra_size) == 4, "");
_Static_assert(_Alignof(struct B017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B017,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B017,e) == 0, "");
#endif
_Static_assert(sizeof(B018) == 4, "");
_Static_assert(_Alignof(B018) == 4, "");
_Static_assert(sizeof(struct B018_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B018_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B018_extra_packed) == 1, "");
_Static_assert(sizeof(struct B018_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B018_extra_size) == 6, "");
_Static_assert(_Alignof(struct B018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B018,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B018,e) == 0, "");
#endif
_Static_assert(sizeof(B019) == 4, "");
_Static_assert(_Alignof(B019) == 4, "");
_Static_assert(sizeof(struct B019_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B019_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B019_extra_packed) == 1, "");
_Static_assert(sizeof(struct B019_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B019_extra_size) == 6, "");
_Static_assert(_Alignof(struct B019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B019,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B019,e) == 0, "");
#endif
_Static_assert(sizeof(B100) == 8, "");
_Static_assert(_Alignof(B100) == 8, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B100_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 10, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B100,e) == 0, "");
#endif
_Static_assert(sizeof(B101) == 1, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 3, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B101,e) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B102,e) == 0, "");
#endif
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B103,e) == 0, "");
#endif
_Static_assert(sizeof(B104) == 8, "");
_Static_assert(_Alignof(B104) == 8, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B104_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 10, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B104,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B104,e) == 0, "");
#endif
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B105,e) == 0, "");
#endif
_Static_assert(sizeof(B106) == 1, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 3, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B106,e) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B107,e) == 0, "");
#endif
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 4, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B108,e) == 0, "");
#endif
_Static_assert(sizeof(B109) == 8, "");
_Static_assert(_Alignof(B109) == 8, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B109_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 10, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B109,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B109,e) == 0, "");
#endif
_Static_assert(sizeof(B110) == 8, "");
_Static_assert(_Alignof(B110) == 8, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B110_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 10, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B110,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B110,e) == 0, "");
#endif
_Static_assert(sizeof(B111) == 8, "");
_Static_assert(_Alignof(B111) == 1, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 10, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B111,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B111,e) == 0, "");
#endif
_Static_assert(sizeof(B112) == 8, "");
_Static_assert(_Alignof(B112) == 2, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B112_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 10, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B112,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B112,e) == 0, "");
#endif
_Static_assert(sizeof(B113) == 8, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 10, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B113,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B113,e) == 0, "");
#endif
_Static_assert(sizeof(B114) == 8, "");
_Static_assert(_Alignof(B114) == 8, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B114_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 10, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B114,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B114,e) == 0, "");
#endif
_Static_assert(sizeof(B115) == 8, "");
_Static_assert(_Alignof(B115) == 2, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B115_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 10, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B115,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B115,e) == 0, "");
#endif
_Static_assert(sizeof(B116) == 8, "");
_Static_assert(_Alignof(B116) == 1, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 10, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B116,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B116,e) == 0, "");
#endif
_Static_assert(sizeof(B117) == 8, "");
_Static_assert(_Alignof(B117) == 2, "");
_Static_assert(sizeof(struct B117_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B117_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B117_extra_packed) == 1, "");
_Static_assert(sizeof(struct B117_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B117_extra_size) == 10, "");
_Static_assert(_Alignof(struct B117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B117,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B117,e) == 0, "");
#endif
_Static_assert(sizeof(B118) == 8, "");
_Static_assert(_Alignof(B118) == 4, "");
_Static_assert(sizeof(struct B118_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B118_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B118_extra_packed) == 1, "");
_Static_assert(sizeof(struct B118_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B118_extra_size) == 10, "");
_Static_assert(_Alignof(struct B118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B118,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B118,e) == 0, "");
#endif
_Static_assert(sizeof(B119) == 8, "");
_Static_assert(_Alignof(B119) == 8, "");
_Static_assert(sizeof(struct B119_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B119_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B119_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B119_extra_packed) == 1, "");
_Static_assert(sizeof(struct B119_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B119_extra_size) == 10, "");
_Static_assert(_Alignof(struct B119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B119,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B119,e) == 0, "");
#endif
_Static_assert(sizeof(B200) == 1, "");
_Static_assert(_Alignof(B200) == 1, "");
_Static_assert(sizeof(struct B200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B200_extra_packed) == 1, "");
_Static_assert(sizeof(struct B200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_size) == 3, "");
_Static_assert(_Alignof(struct B200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B200,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B200,e) == 0, "");
#endif
_Static_assert(sizeof(B201) == 1, "");
_Static_assert(_Alignof(B201) == 1, "");
_Static_assert(sizeof(struct B201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B201_extra_packed) == 1, "");
_Static_assert(sizeof(struct B201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_size) == 3, "");
_Static_assert(_Alignof(struct B201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B201,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B201,e) == 0, "");
#endif
_Static_assert(sizeof(B202) == 1, "");
_Static_assert(_Alignof(B202) == 1, "");
_Static_assert(sizeof(struct B202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B202_extra_packed) == 1, "");
_Static_assert(sizeof(struct B202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_size) == 3, "");
_Static_assert(_Alignof(struct B202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B202,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B202,e) == 0, "");
#endif
_Static_assert(sizeof(B203) == 1, "");
_Static_assert(_Alignof(B203) == 1, "");
_Static_assert(sizeof(struct B203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B203_extra_packed) == 1, "");
_Static_assert(sizeof(struct B203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_size) == 3, "");
_Static_assert(_Alignof(struct B203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B203,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B203,e) == 0, "");
#endif
_Static_assert(sizeof(B204) == 1, "");
_Static_assert(_Alignof(B204) == 1, "");
_Static_assert(sizeof(struct B204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B204_extra_packed) == 1, "");
_Static_assert(sizeof(struct B204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_size) == 3, "");
_Static_assert(_Alignof(struct B204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B204,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B204,e) == 0, "");
#endif
_Static_assert(sizeof(B205) == 1, "");
_Static_assert(_Alignof(B205) == 1, "");
_Static_assert(sizeof(struct B205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B205_extra_packed) == 1, "");
_Static_assert(sizeof(struct B205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_size) == 3, "");
_Static_assert(_Alignof(struct B205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B205,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B205,e) == 0, "");
#endif
_Static_assert(sizeof(B206) == 1, "");
_Static_assert(_Alignof(B206) == 1, "");
_Static_assert(sizeof(struct B206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B206_extra_packed) == 1, "");
_Static_assert(sizeof(struct B206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_size) == 3, "");
_Static_assert(_Alignof(struct B206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B206,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B206,e) == 0, "");
#endif
_Static_assert(sizeof(B207) == 1, "");
_Static_assert(_Alignof(B207) == 1, "");
_Static_assert(sizeof(struct B207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B207_extra_packed) == 1, "");
_Static_assert(sizeof(struct B207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_size) == 3, "");
_Static_assert(_Alignof(struct B207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B207,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B207,e) == 0, "");
#endif
_Static_assert(sizeof(B208) == 1, "");
_Static_assert(_Alignof(B208) == 1, "");
_Static_assert(sizeof(struct B208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B208_extra_packed) == 1, "");
_Static_assert(sizeof(struct B208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_size) == 3, "");
_Static_assert(_Alignof(struct B208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B208,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B208,e) == 0, "");
#endif
_Static_assert(sizeof(B209) == 1, "");
_Static_assert(_Alignof(B209) == 1, "");
_Static_assert(sizeof(struct B209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B209_extra_packed) == 1, "");
_Static_assert(sizeof(struct B209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_size) == 3, "");
_Static_assert(_Alignof(struct B209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B209,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B209,e) == 0, "");
#endif
_Static_assert(sizeof(B210) == 1, "");
_Static_assert(_Alignof(B210) == 1, "");
_Static_assert(sizeof(struct B210_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B210_extra_packed) == 1, "");
_Static_assert(sizeof(struct B210_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_size) == 3, "");
_Static_assert(_Alignof(struct B210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B210,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B210,e) == 0, "");
#endif
_Static_assert(sizeof(B211) == 1, "");
_Static_assert(_Alignof(B211) == 1, "");
_Static_assert(sizeof(struct B211_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B211_extra_packed) == 1, "");
_Static_assert(sizeof(struct B211_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_size) == 3, "");
_Static_assert(_Alignof(struct B211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B211,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B211,e) == 0, "");
#endif
_Static_assert(sizeof(B212) == 1, "");
_Static_assert(_Alignof(B212) == 1, "");
_Static_assert(sizeof(struct B212_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B212_extra_packed) == 1, "");
_Static_assert(sizeof(struct B212_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_size) == 3, "");
_Static_assert(_Alignof(struct B212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B212,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B212,e) == 0, "");
#endif
_Static_assert(sizeof(B213) == 1, "");
_Static_assert(_Alignof(B213) == 1, "");
_Static_assert(sizeof(struct B213_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B213_extra_packed) == 1, "");
_Static_assert(sizeof(struct B213_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_size) == 3, "");
_Static_assert(_Alignof(struct B213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B213,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B213,e) == 0, "");
#endif
_Static_assert(sizeof(B214) == 1, "");
_Static_assert(_Alignof(B214) == 1, "");
_Static_assert(sizeof(struct B214_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B214_extra_packed) == 1, "");
_Static_assert(sizeof(struct B214_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_size) == 3, "");
_Static_assert(_Alignof(struct B214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B214,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B214,e) == 0, "");
#endif
_Static_assert(sizeof(B215) == 1, "");
_Static_assert(_Alignof(B215) == 1, "");
_Static_assert(sizeof(struct B215_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B215_extra_packed) == 1, "");
_Static_assert(sizeof(struct B215_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_size) == 3, "");
_Static_assert(_Alignof(struct B215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B215,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B215,e) == 0, "");
#endif
_Static_assert(sizeof(B216) == 1, "");
_Static_assert(_Alignof(B216) == 1, "");
_Static_assert(sizeof(struct B216_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B216_extra_packed) == 1, "");
_Static_assert(sizeof(struct B216_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_size) == 3, "");
_Static_assert(_Alignof(struct B216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B216,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B216,e) == 0, "");
#endif
_Static_assert(sizeof(B217) == 1, "");
_Static_assert(_Alignof(B217) == 1, "");
_Static_assert(sizeof(struct B217_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B217_extra_packed) == 1, "");
_Static_assert(sizeof(struct B217_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_size) == 3, "");
_Static_assert(_Alignof(struct B217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B217,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B217,e) == 0, "");
#endif
_Static_assert(sizeof(B218) == 1, "");
_Static_assert(_Alignof(B218) == 1, "");
_Static_assert(sizeof(struct B218_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B218_extra_packed) == 1, "");
_Static_assert(sizeof(struct B218_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_size) == 3, "");
_Static_assert(_Alignof(struct B218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B218,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B218,e) == 0, "");
#endif
_Static_assert(sizeof(B219) == 1, "");
_Static_assert(_Alignof(B219) == 1, "");
_Static_assert(sizeof(struct B219_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B219_extra_packed) == 1, "");
_Static_assert(sizeof(struct B219_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_size) == 3, "");
_Static_assert(_Alignof(struct B219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B219,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B219,e) == 0, "");
#endif
_Static_assert(sizeof(B300) == 8, "");
_Static_assert(_Alignof(B300) == 8, "");
_Static_assert(sizeof(struct B300_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B300_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B300_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B300_extra_packed) == 1, "");
_Static_assert(sizeof(struct B300_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B300_extra_size) == 10, "");
_Static_assert(_Alignof(struct B300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B300,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B300,e) == 0, "");
#endif
_Static_assert(sizeof(B301) == 1, "");
_Static_assert(_Alignof(B301) == 1, "");
_Static_assert(sizeof(struct B301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B301_extra_packed) == 1, "");
_Static_assert(sizeof(struct B301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_size) == 3, "");
_Static_assert(_Alignof(struct B301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B301,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B301,e) == 0, "");
#endif
_Static_assert(sizeof(B302) == 2, "");
_Static_assert(_Alignof(B302) == 2, "");
_Static_assert(sizeof(struct B302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B302_extra_packed) == 1, "");
_Static_assert(sizeof(struct B302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B302_extra_size) == 4, "");
_Static_assert(_Alignof(struct B302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B302,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B302,e) == 0, "");
#endif
_Static_assert(sizeof(B303) == 4, "");
_Static_assert(_Alignof(B303) == 4, "");
_Static_assert(sizeof(struct B303_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B303_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B303_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B303_extra_packed) == 1, "");
_Static_assert(sizeof(struct B303_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B303_extra_size) == 6, "");
_Static_assert(_Alignof(struct B303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B303,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B303,e) == 0, "");
#endif
_Static_assert(sizeof(B304) == 8, "");
_Static_assert(_Alignof(B304) == 8, "");
_Static_assert(sizeof(struct B304_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B304_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B304_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B304_extra_packed) == 1, "");
_Static_assert(sizeof(struct B304_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B304_extra_size) == 10, "");
_Static_assert(_Alignof(struct B304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B304,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B304,e) == 0, "");
#endif
_Static_assert(sizeof(B305) == 1, "");
_Static_assert(_Alignof(B305) == 1, "");
_Static_assert(sizeof(struct B305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B305_extra_packed) == 1, "");
_Static_assert(sizeof(struct B305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_size) == 3, "");
_Static_assert(_Alignof(struct B305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B305,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B305,e) == 0, "");
#endif
_Static_assert(sizeof(B306) == 1, "");
_Static_assert(_Alignof(B306) == 1, "");
_Static_assert(sizeof(struct B306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B306_extra_packed) == 1, "");
_Static_assert(sizeof(struct B306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_size) == 3, "");
_Static_assert(_Alignof(struct B306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B306,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B306,e) == 0, "");
#endif
_Static_assert(sizeof(B307) == 2, "");
_Static_assert(_Alignof(B307) == 2, "");
_Static_assert(sizeof(struct B307_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B307_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B307_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B307_extra_packed) == 1, "");
_Static_assert(sizeof(struct B307_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_size) == 4, "");
_Static_assert(_Alignof(struct B307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B307,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B307,e) == 0, "");
#endif
_Static_assert(sizeof(B308) == 4, "");
_Static_assert(_Alignof(B308) == 4, "");
_Static_assert(sizeof(struct B308_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B308_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B308_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B308_extra_packed) == 1, "");
_Static_assert(sizeof(struct B308_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_size) == 6, "");
_Static_assert(_Alignof(struct B308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B308,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B308,e) == 0, "");
#endif
_Static_assert(sizeof(B309) == 8, "");
_Static_assert(_Alignof(B309) == 8, "");
_Static_assert(sizeof(struct B309_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B309_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B309_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B309_extra_packed) == 1, "");
_Static_assert(sizeof(struct B309_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_size) == 10, "");
_Static_assert(_Alignof(struct B309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B309,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B309,e) == 0, "");
#endif
_Static_assert(sizeof(B310) == 8, "");
_Static_assert(_Alignof(B310) == 8, "");
_Static_assert(sizeof(struct B310_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B310_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B310_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B310_extra_packed) == 1, "");
_Static_assert(sizeof(struct B310_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B310_extra_size) == 10, "");
_Static_assert(_Alignof(struct B310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B310,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B310,e) == 0, "");
#endif
_Static_assert(sizeof(B311) == 8, "");
_Static_assert(_Alignof(B311) == 1, "");
_Static_assert(sizeof(struct B311_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B311_extra_packed) == 1, "");
_Static_assert(sizeof(struct B311_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_size) == 10, "");
_Static_assert(_Alignof(struct B311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B311,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B311,e) == 0, "");
#endif
_Static_assert(sizeof(B312) == 8, "");
_Static_assert(_Alignof(B312) == 2, "");
_Static_assert(sizeof(struct B312_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B312_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B312_extra_packed) == 1, "");
_Static_assert(sizeof(struct B312_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B312_extra_size) == 10, "");
_Static_assert(_Alignof(struct B312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B312,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B312,e) == 0, "");
#endif
_Static_assert(sizeof(B313) == 8, "");
_Static_assert(_Alignof(B313) == 4, "");
_Static_assert(sizeof(struct B313_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B313_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B313_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B313_extra_packed) == 1, "");
_Static_assert(sizeof(struct B313_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B313_extra_size) == 10, "");
_Static_assert(_Alignof(struct B313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B313,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B313,e) == 0, "");
#endif
_Static_assert(sizeof(B314) == 8, "");
_Static_assert(_Alignof(B314) == 8, "");
_Static_assert(sizeof(struct B314_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B314_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B314_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B314_extra_packed) == 1, "");
_Static_assert(sizeof(struct B314_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B314_extra_size) == 10, "");
_Static_assert(_Alignof(struct B314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B314,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B314,e) == 0, "");
#endif
_Static_assert(sizeof(B315) == 8, "");
_Static_assert(_Alignof(B315) == 1, "");
_Static_assert(sizeof(struct B315_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B315_extra_packed) == 1, "");
_Static_assert(sizeof(struct B315_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_size) == 10, "");
_Static_assert(_Alignof(struct B315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B315,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B315,e) == 0, "");
#endif
_Static_assert(sizeof(B316) == 8, "");
_Static_assert(_Alignof(B316) == 1, "");
_Static_assert(sizeof(struct B316_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B316_extra_packed) == 1, "");
_Static_assert(sizeof(struct B316_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_size) == 10, "");
_Static_assert(_Alignof(struct B316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B316,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B316,e) == 0, "");
#endif
_Static_assert(sizeof(B317) == 8, "");
_Static_assert(_Alignof(B317) == 2, "");
_Static_assert(sizeof(struct B317_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B317_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B317_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B317_extra_packed) == 1, "");
_Static_assert(sizeof(struct B317_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_size) == 10, "");
_Static_assert(_Alignof(struct B317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B317,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B317,e) == 0, "");
#endif
_Static_assert(sizeof(B318) == 8, "");
_Static_assert(_Alignof(B318) == 4, "");
_Static_assert(sizeof(struct B318_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B318_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B318_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B318_extra_packed) == 1, "");
_Static_assert(sizeof(struct B318_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_size) == 10, "");
_Static_assert(_Alignof(struct B318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B318,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B318,e) == 0, "");
#endif
_Static_assert(sizeof(B319) == 8, "");
_Static_assert(_Alignof(B319) == 8, "");
_Static_assert(sizeof(struct B319_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B319_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B319_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B319_extra_packed) == 1, "");
_Static_assert(sizeof(struct B319_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_size) == 10, "");
_Static_assert(_Alignof(struct B319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B319,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B319,e) == 0, "");
#endif
_Static_assert(sizeof(B410) == 8, "");
_Static_assert(_Alignof(B410) == 8, "");
_Static_assert(sizeof(struct B410_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B410_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B410_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B410_extra_packed) == 1, "");
_Static_assert(sizeof(struct B410_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B410_extra_size) == 10, "");
_Static_assert(_Alignof(struct B410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B410,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B410,e) == 0, "");
#endif
_Static_assert(sizeof(B411) == 8, "");
_Static_assert(_Alignof(B411) == 1, "");
_Static_assert(sizeof(struct B411_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B411_extra_packed) == 1, "");
_Static_assert(sizeof(struct B411_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_size) == 10, "");
_Static_assert(_Alignof(struct B411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B411,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B411,e) == 0, "");
#endif
_Static_assert(sizeof(B412) == 8, "");
_Static_assert(_Alignof(B412) == 2, "");
_Static_assert(sizeof(struct B412_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B412_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B412_extra_packed) == 1, "");
_Static_assert(sizeof(struct B412_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B412_extra_size) == 10, "");
_Static_assert(_Alignof(struct B412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B412,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B412,e) == 0, "");
#endif
_Static_assert(sizeof(B413) == 8, "");
_Static_assert(_Alignof(B413) == 4, "");
_Static_assert(sizeof(struct B413_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B413_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B413_extra_packed) == 1, "");
_Static_assert(sizeof(struct B413_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B413_extra_size) == 10, "");
_Static_assert(_Alignof(struct B413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B413,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B413,e) == 0, "");
#endif
_Static_assert(sizeof(B414) == 8, "");
_Static_assert(_Alignof(B414) == 8, "");
_Static_assert(sizeof(struct B414_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B414_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B414_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B414_extra_packed) == 1, "");
_Static_assert(sizeof(struct B414_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B414_extra_size) == 10, "");
_Static_assert(_Alignof(struct B414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B414,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B414,e) == 0, "");
#endif
_Static_assert(sizeof(B415) == 8, "");
_Static_assert(_Alignof(B415) == 2, "");
_Static_assert(sizeof(struct B415_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B415_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B415_extra_packed) == 1, "");
_Static_assert(sizeof(struct B415_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B415_extra_size) == 10, "");
_Static_assert(_Alignof(struct B415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B415,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B415,e) == 0, "");
#endif
_Static_assert(sizeof(B416) == 8, "");
_Static_assert(_Alignof(B416) == 1, "");
_Static_assert(sizeof(struct B416_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B416_extra_packed) == 1, "");
_Static_assert(sizeof(struct B416_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_size) == 10, "");
_Static_assert(_Alignof(struct B416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B416,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B416,e) == 0, "");
#endif
_Static_assert(sizeof(B417) == 8, "");
_Static_assert(_Alignof(B417) == 2, "");
_Static_assert(sizeof(struct B417_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B417_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B417_extra_packed) == 1, "");
_Static_assert(sizeof(struct B417_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B417_extra_size) == 10, "");
_Static_assert(_Alignof(struct B417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B417,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B417,e) == 0, "");
#endif
_Static_assert(sizeof(B418) == 8, "");
_Static_assert(_Alignof(B418) == 4, "");
_Static_assert(sizeof(struct B418_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B418_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B418_extra_packed) == 1, "");
_Static_assert(sizeof(struct B418_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B418_extra_size) == 10, "");
_Static_assert(_Alignof(struct B418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B418,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B418,e) == 0, "");
#endif
_Static_assert(sizeof(B419) == 8, "");
_Static_assert(_Alignof(B419) == 8, "");
_Static_assert(sizeof(struct B419_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B419_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B419_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B419_extra_packed) == 1, "");
_Static_assert(sizeof(struct B419_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B419_extra_size) == 10, "");
_Static_assert(_Alignof(struct B419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B419,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B419,e) == 0, "");
#endif
_Static_assert(sizeof(B510) == 8, "");
_Static_assert(_Alignof(B510) == 8, "");
_Static_assert(sizeof(struct B510_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B510_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B510_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B510_extra_packed) == 1, "");
_Static_assert(sizeof(struct B510_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B510_extra_size) == 10, "");
_Static_assert(_Alignof(struct B510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B510,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B510,e) == 0, "");
#endif
_Static_assert(sizeof(B511) == 8, "");
_Static_assert(_Alignof(B511) == 1, "");
_Static_assert(sizeof(struct B511_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B511_extra_packed) == 1, "");
_Static_assert(sizeof(struct B511_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_size) == 10, "");
_Static_assert(_Alignof(struct B511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B511,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B511,e) == 0, "");
#endif
_Static_assert(sizeof(B512) == 8, "");
_Static_assert(_Alignof(B512) == 2, "");
_Static_assert(sizeof(struct B512_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B512_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B512_extra_packed) == 1, "");
_Static_assert(sizeof(struct B512_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B512_extra_size) == 10, "");
_Static_assert(_Alignof(struct B512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B512,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B512,e) == 0, "");
#endif
_Static_assert(sizeof(B513) == 8, "");
_Static_assert(_Alignof(B513) == 4, "");
_Static_assert(sizeof(struct B513_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B513_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B513_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B513_extra_packed) == 1, "");
_Static_assert(sizeof(struct B513_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B513_extra_size) == 10, "");
_Static_assert(_Alignof(struct B513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B513,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B513,e) == 0, "");
#endif
_Static_assert(sizeof(B514) == 8, "");
_Static_assert(_Alignof(B514) == 8, "");
_Static_assert(sizeof(struct B514_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B514_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B514_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B514_extra_packed) == 1, "");
_Static_assert(sizeof(struct B514_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B514_extra_size) == 10, "");
_Static_assert(_Alignof(struct B514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B514,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B514,e) == 0, "");
#endif
_Static_assert(sizeof(B515) == 8, "");
_Static_assert(_Alignof(B515) == 1, "");
_Static_assert(sizeof(struct B515_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B515_extra_packed) == 1, "");
_Static_assert(sizeof(struct B515_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_size) == 10, "");
_Static_assert(_Alignof(struct B515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B515,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B515,e) == 0, "");
#endif
_Static_assert(sizeof(B516) == 8, "");
_Static_assert(_Alignof(B516) == 1, "");
_Static_assert(sizeof(struct B516_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B516_extra_packed) == 1, "");
_Static_assert(sizeof(struct B516_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_size) == 10, "");
_Static_assert(_Alignof(struct B516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B516,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B516,e) == 0, "");
#endif
_Static_assert(sizeof(B517) == 8, "");
_Static_assert(_Alignof(B517) == 2, "");
_Static_assert(sizeof(struct B517_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B517_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B517_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B517_extra_packed) == 1, "");
_Static_assert(sizeof(struct B517_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_size) == 10, "");
_Static_assert(_Alignof(struct B517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B517,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B517,e) == 0, "");
#endif
_Static_assert(sizeof(B518) == 8, "");
_Static_assert(_Alignof(B518) == 4, "");
_Static_assert(sizeof(struct B518_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B518_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B518_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B518_extra_packed) == 1, "");
_Static_assert(sizeof(struct B518_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_size) == 10, "");
_Static_assert(_Alignof(struct B518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B518,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B518,e) == 0, "");
#endif
_Static_assert(sizeof(B519) == 8, "");
_Static_assert(_Alignof(B519) == 8, "");
_Static_assert(sizeof(struct B519_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B519_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B519_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B519_extra_packed) == 1, "");
_Static_assert(sizeof(struct B519_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_size) == 10, "");
_Static_assert(_Alignof(struct B519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B519,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B519,e) == 0, "");
#endif
// MAPPING|TWO|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|END
// repr targets Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl")
#elif defined(TWO)
_Static_assert(sizeof(A000) == 4, "");
_Static_assert(_Alignof(A000) == 2, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 6, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A000,e) == 17, "");
#endif
_Static_assert(sizeof(A001) == 2, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 4, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A001,e) == 9, "");
#endif
_Static_assert(sizeof(A002) == 4, "");
_Static_assert(_Alignof(A002) == 2, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A002_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 6, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A002,e) == 17, "");
#endif
_Static_assert(sizeof(A003) == 8, "");
_Static_assert(_Alignof(A003) == 4, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A003_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 10, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A003,e) == 33, "");
#endif
_Static_assert(sizeof(A004) == 8, "");
_Static_assert(_Alignof(A004) == 4, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A004_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 10, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A004,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A004,e) == 33, "");
#endif
_Static_assert(sizeof(A005) == 4, "");
_Static_assert(_Alignof(A005) == 2, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A005_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 6, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A005,e) == 17, "");
#endif
_Static_assert(sizeof(A006) == 2, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 4, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A006,e) == 9, "");
#endif
_Static_assert(sizeof(A007) == 4, "");
_Static_assert(_Alignof(A007) == 2, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A007_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 6, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A007,e) == 17, "");
#endif
_Static_assert(sizeof(A008) == 8, "");
_Static_assert(_Alignof(A008) == 4, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A008_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 10, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A008,e) == 33, "");
#endif
_Static_assert(sizeof(A009) == 8, "");
_Static_assert(_Alignof(A009) == 4, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A009_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 10, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A009,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A009,e) == 33, "");
#endif
_Static_assert(sizeof(A010) == 4, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 6, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A010,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A010,e) == 24, "");
#endif
_Static_assert(sizeof(A011) == 3, "");
_Static_assert(_Alignof(A011) == 1, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 5, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A011,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A011,e) == 16, "");
#endif
_Static_assert(sizeof(A012) == 4, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 6, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A012,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A012,e) == 24, "");
#endif
_Static_assert(sizeof(A013) == 8, "");
_Static_assert(_Alignof(A013) == 4, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A013_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 10, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A013,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A013,e) == 40, "");
#endif
_Static_assert(sizeof(A014) == 8, "");
_Static_assert(_Alignof(A014) == 4, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A014_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 10, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A014,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A014,e) == 40, "");
#endif
_Static_assert(sizeof(A015) == 4, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 6, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A015,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A015,e) == 24, "");
#endif
_Static_assert(sizeof(A016) == 3, "");
_Static_assert(_Alignof(A016) == 1, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 5, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A016,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A016,e) == 16, "");
#endif
_Static_assert(sizeof(A017) == 4, "");
_Static_assert(_Alignof(A017) == 2, "");
_Static_assert(sizeof(struct A017_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A017_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A017_extra_packed) == 1, "");
_Static_assert(sizeof(struct A017_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A017_extra_size) == 6, "");
_Static_assert(_Alignof(struct A017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A017,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A017,e) == 24, "");
#endif
_Static_assert(sizeof(A018) == 8, "");
_Static_assert(_Alignof(A018) == 4, "");
_Static_assert(sizeof(struct A018_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A018_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A018_extra_packed) == 1, "");
_Static_assert(sizeof(struct A018_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A018_extra_size) == 10, "");
_Static_assert(_Alignof(struct A018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A018,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A018,e) == 40, "");
#endif
_Static_assert(sizeof(A019) == 8, "");
_Static_assert(_Alignof(A019) == 4, "");
_Static_assert(sizeof(struct A019_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A019_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A019_extra_packed) == 1, "");
_Static_assert(sizeof(struct A019_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A019_extra_size) == 10, "");
_Static_assert(_Alignof(struct A019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A019,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A019,e) == 40, "");
#endif
_Static_assert(sizeof(A100) == 8, "");
_Static_assert(_Alignof(A100) == 8, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A100_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 10, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A100,e) == 17, "");
#endif
_Static_assert(sizeof(A101) == 2, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 4, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A101,e) == 9, "");
#endif
_Static_assert(sizeof(A102) == 4, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 6, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A102,e) == 17, "");
#endif
_Static_assert(sizeof(A103) == 8, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 10, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A103,e) == 33, "");
#endif
_Static_assert(sizeof(A104) == 8, "");
_Static_assert(_Alignof(A104) == 8, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A104_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 10, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A104,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A104,e) == 33, "");
#endif
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A105,e) == 17, "");
#endif
_Static_assert(sizeof(A106) == 2, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 4, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A106,e) == 9, "");
#endif
_Static_assert(sizeof(A107) == 4, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 6, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A107,e) == 17, "");
#endif
_Static_assert(sizeof(A108) == 8, "");
_Static_assert(_Alignof(A108) == 4, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A108_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 10, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A108,e) == 33, "");
#endif
_Static_assert(sizeof(A109) == 8, "");
_Static_assert(_Alignof(A109) == 8, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A109_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 10, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A109,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A109,e) == 33, "");
#endif
_Static_assert(sizeof(A110) == 16, "");
_Static_assert(_Alignof(A110) == 8, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A110_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 18, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A110,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(A110,e) == 127, "");
#endif
_Static_assert(sizeof(A111) == 9, "");
_Static_assert(_Alignof(A111) == 1, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 11, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A111,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A111,e) == 71, "");
#endif
_Static_assert(sizeof(A112) == 10, "");
_Static_assert(_Alignof(A112) == 2, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A112_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 12, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A112,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A112,e) == 79, "");
#endif
_Static_assert(sizeof(A113) == 12, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 14, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A113,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A113,e) == 95, "");
#endif
_Static_assert(sizeof(A114) == 16, "");
_Static_assert(_Alignof(A114) == 8, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A114_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 18, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A114,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A114,e) == 95, "");
#endif
_Static_assert(sizeof(A115) == 10, "");
_Static_assert(_Alignof(A115) == 2, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A115_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 12, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A115,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A115,e) == 79, "");
#endif
_Static_assert(sizeof(A116) == 9, "");
_Static_assert(_Alignof(A116) == 1, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 11, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A116,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A116,e) == 71, "");
#endif
_Static_assert(sizeof(A117) == 10, "");
_Static_assert(_Alignof(A117) == 2, "");
_Static_assert(sizeof(struct A117_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A117_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A117_extra_packed) == 1, "");
_Static_assert(sizeof(struct A117_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A117_extra_size) == 12, "");
_Static_assert(_Alignof(struct A117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A117,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A117,e) == 79, "");
#endif
_Static_assert(sizeof(A118) == 12, "");
_Static_assert(_Alignof(A118) == 4, "");
_Static_assert(sizeof(struct A118_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A118_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A118_extra_packed) == 1, "");
_Static_assert(sizeof(struct A118_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A118_extra_size) == 14, "");
_Static_assert(_Alignof(struct A118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A118,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A118,e) == 95, "");
#endif
_Static_assert(sizeof(A119) == 16, "");
_Static_assert(_Alignof(A119) == 8, "");
_Static_assert(sizeof(struct A119_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A119_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A119_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A119_extra_packed) == 1, "");
_Static_assert(sizeof(struct A119_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A119_extra_size) == 18, "");
_Static_assert(_Alignof(struct A119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A119,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A119,e) == 95, "");
#endif
_Static_assert(sizeof(A200) == 1, "");
_Static_assert(_Alignof(A200) == 1, "");
_Static_assert(sizeof(struct A200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A200_extra_packed) == 1, "");
_Static_assert(sizeof(struct A200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_size) == 3, "");
_Static_assert(_Alignof(struct A200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A200,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A200,e) == 2, "");
#endif
_Static_assert(sizeof(A201) == 1, "");
_Static_assert(_Alignof(A201) == 1, "");
_Static_assert(sizeof(struct A201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A201_extra_packed) == 1, "");
_Static_assert(sizeof(struct A201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_size) == 3, "");
_Static_assert(_Alignof(struct A201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A201,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A201,e) == 2, "");
#endif
_Static_assert(sizeof(A202) == 1, "");
_Static_assert(_Alignof(A202) == 1, "");
_Static_assert(sizeof(struct A202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A202_extra_packed) == 1, "");
_Static_assert(sizeof(struct A202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_size) == 3, "");
_Static_assert(_Alignof(struct A202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A202,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A202,e) == 2, "");
#endif
_Static_assert(sizeof(A203) == 1, "");
_Static_assert(_Alignof(A203) == 1, "");
_Static_assert(sizeof(struct A203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A203_extra_packed) == 1, "");
_Static_assert(sizeof(struct A203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_size) == 3, "");
_Static_assert(_Alignof(struct A203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A203,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A203,e) == 2, "");
#endif
_Static_assert(sizeof(A204) == 1, "");
_Static_assert(_Alignof(A204) == 1, "");
_Static_assert(sizeof(struct A204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A204_extra_packed) == 1, "");
_Static_assert(sizeof(struct A204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_size) == 3, "");
_Static_assert(_Alignof(struct A204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A204,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A204,e) == 2, "");
#endif
_Static_assert(sizeof(A205) == 1, "");
_Static_assert(_Alignof(A205) == 1, "");
_Static_assert(sizeof(struct A205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A205_extra_packed) == 1, "");
_Static_assert(sizeof(struct A205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_size) == 3, "");
_Static_assert(_Alignof(struct A205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A205,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A205,e) == 2, "");
#endif
_Static_assert(sizeof(A206) == 1, "");
_Static_assert(_Alignof(A206) == 1, "");
_Static_assert(sizeof(struct A206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A206_extra_packed) == 1, "");
_Static_assert(sizeof(struct A206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_size) == 3, "");
_Static_assert(_Alignof(struct A206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A206,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A206,e) == 2, "");
#endif
_Static_assert(sizeof(A207) == 1, "");
_Static_assert(_Alignof(A207) == 1, "");
_Static_assert(sizeof(struct A207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A207_extra_packed) == 1, "");
_Static_assert(sizeof(struct A207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_size) == 3, "");
_Static_assert(_Alignof(struct A207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A207,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A207,e) == 2, "");
#endif
_Static_assert(sizeof(A208) == 1, "");
_Static_assert(_Alignof(A208) == 1, "");
_Static_assert(sizeof(struct A208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A208_extra_packed) == 1, "");
_Static_assert(sizeof(struct A208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_size) == 3, "");
_Static_assert(_Alignof(struct A208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A208,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A208,e) == 2, "");
#endif
_Static_assert(sizeof(A209) == 1, "");
_Static_assert(_Alignof(A209) == 1, "");
_Static_assert(sizeof(struct A209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A209_extra_packed) == 1, "");
_Static_assert(sizeof(struct A209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_size) == 3, "");
_Static_assert(_Alignof(struct A209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A209,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A209,e) == 2, "");
#endif
_Static_assert(sizeof(A210) == 3, "");
_Static_assert(_Alignof(A210) == 1, "");
_Static_assert(sizeof(struct A210_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A210_extra_packed) == 1, "");
_Static_assert(sizeof(struct A210_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_size) == 5, "");
_Static_assert(_Alignof(struct A210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A210,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A210,e) == 16, "");
#endif
_Static_assert(sizeof(A211) == 2, "");
_Static_assert(_Alignof(A211) == 1, "");
_Static_assert(sizeof(struct A211_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A211_extra_packed) == 1, "");
_Static_assert(sizeof(struct A211_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_size) == 4, "");
_Static_assert(_Alignof(struct A211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A211,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A211,e) == 9, "");
#endif
_Static_assert(sizeof(A212) == 2, "");
_Static_assert(_Alignof(A212) == 1, "");
_Static_assert(sizeof(struct A212_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A212_extra_packed) == 1, "");
_Static_assert(sizeof(struct A212_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_size) == 4, "");
_Static_assert(_Alignof(struct A212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A212,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A212,e) == 9, "");
#endif
_Static_assert(sizeof(A213) == 2, "");
_Static_assert(_Alignof(A213) == 1, "");
_Static_assert(sizeof(struct A213_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A213_extra_packed) == 1, "");
_Static_assert(sizeof(struct A213_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_size) == 4, "");
_Static_assert(_Alignof(struct A213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A213,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A213,e) == 9, "");
#endif
_Static_assert(sizeof(A214) == 2, "");
_Static_assert(_Alignof(A214) == 1, "");
_Static_assert(sizeof(struct A214_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A214_extra_packed) == 1, "");
_Static_assert(sizeof(struct A214_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_size) == 4, "");
_Static_assert(_Alignof(struct A214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A214,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A214,e) == 9, "");
#endif
_Static_assert(sizeof(A215) == 2, "");
_Static_assert(_Alignof(A215) == 1, "");
_Static_assert(sizeof(struct A215_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A215_extra_packed) == 1, "");
_Static_assert(sizeof(struct A215_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_size) == 4, "");
_Static_assert(_Alignof(struct A215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A215,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A215,e) == 9, "");
#endif
_Static_assert(sizeof(A216) == 2, "");
_Static_assert(_Alignof(A216) == 1, "");
_Static_assert(sizeof(struct A216_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A216_extra_packed) == 1, "");
_Static_assert(sizeof(struct A216_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_size) == 4, "");
_Static_assert(_Alignof(struct A216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A216,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A216,e) == 9, "");
#endif
_Static_assert(sizeof(A217) == 2, "");
_Static_assert(_Alignof(A217) == 1, "");
_Static_assert(sizeof(struct A217_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A217_extra_packed) == 1, "");
_Static_assert(sizeof(struct A217_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_size) == 4, "");
_Static_assert(_Alignof(struct A217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A217,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A217,e) == 9, "");
#endif
_Static_assert(sizeof(A218) == 2, "");
_Static_assert(_Alignof(A218) == 1, "");
_Static_assert(sizeof(struct A218_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A218_extra_packed) == 1, "");
_Static_assert(sizeof(struct A218_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_size) == 4, "");
_Static_assert(_Alignof(struct A218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A218,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A218,e) == 9, "");
#endif
_Static_assert(sizeof(A219) == 2, "");
_Static_assert(_Alignof(A219) == 1, "");
_Static_assert(sizeof(struct A219_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A219_extra_packed) == 1, "");
_Static_assert(sizeof(struct A219_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_size) == 4, "");
_Static_assert(_Alignof(struct A219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A219,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A219,e) == 9, "");
#endif
_Static_assert(sizeof(A300) == 8, "");
_Static_assert(_Alignof(A300) == 8, "");
_Static_assert(sizeof(struct A300_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A300_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A300_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A300_extra_packed) == 1, "");
_Static_assert(sizeof(struct A300_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A300_extra_size) == 10, "");
_Static_assert(_Alignof(struct A300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A300,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A300,e) == 3, "");
#endif
_Static_assert(sizeof(A301) == 1, "");
_Static_assert(_Alignof(A301) == 1, "");
_Static_assert(sizeof(struct A301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A301_extra_packed) == 1, "");
_Static_assert(sizeof(struct A301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_size) == 3, "");
_Static_assert(_Alignof(struct A301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A301,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A301,e) == 3, "");
#endif
_Static_assert(sizeof(A302) == 2, "");
_Static_assert(_Alignof(A302) == 2, "");
_Static_assert(sizeof(struct A302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A302_extra_packed) == 1, "");
_Static_assert(sizeof(struct A302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A302_extra_size) == 4, "");
_Static_assert(_Alignof(struct A302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A302,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A302,e) == 3, "");
#endif
_Static_assert(sizeof(A303) == 4, "");
_Static_assert(_Alignof(A303) == 4, "");
_Static_assert(sizeof(struct A303_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A303_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A303_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A303_extra_packed) == 1, "");
_Static_assert(sizeof(struct A303_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A303_extra_size) == 6, "");
_Static_assert(_Alignof(struct A303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A303,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A303,e) == 3, "");
#endif
_Static_assert(sizeof(A304) == 8, "");
_Static_assert(_Alignof(A304) == 8, "");
_Static_assert(sizeof(struct A304_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A304_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A304_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A304_extra_packed) == 1, "");
_Static_assert(sizeof(struct A304_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A304_extra_size) == 10, "");
_Static_assert(_Alignof(struct A304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A304,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A304,e) == 3, "");
#endif
_Static_assert(sizeof(A305) == 1, "");
_Static_assert(_Alignof(A305) == 1, "");
_Static_assert(sizeof(struct A305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A305_extra_packed) == 1, "");
_Static_assert(sizeof(struct A305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_size) == 3, "");
_Static_assert(_Alignof(struct A305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A305,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A305,e) == 3, "");
#endif
_Static_assert(sizeof(A306) == 1, "");
_Static_assert(_Alignof(A306) == 1, "");
_Static_assert(sizeof(struct A306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A306_extra_packed) == 1, "");
_Static_assert(sizeof(struct A306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_size) == 3, "");
_Static_assert(_Alignof(struct A306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A306,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A306,e) == 3, "");
#endif
_Static_assert(sizeof(A307) == 2, "");
_Static_assert(_Alignof(A307) == 2, "");
_Static_assert(sizeof(struct A307_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A307_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A307_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A307_extra_packed) == 1, "");
_Static_assert(sizeof(struct A307_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_size) == 4, "");
_Static_assert(_Alignof(struct A307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A307,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A307,e) == 3, "");
#endif
_Static_assert(sizeof(A308) == 4, "");
_Static_assert(_Alignof(A308) == 4, "");
_Static_assert(sizeof(struct A308_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A308_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A308_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A308_extra_packed) == 1, "");
_Static_assert(sizeof(struct A308_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_size) == 6, "");
_Static_assert(_Alignof(struct A308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A308,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A308,e) == 3, "");
#endif
_Static_assert(sizeof(A309) == 8, "");
_Static_assert(_Alignof(A309) == 8, "");
_Static_assert(sizeof(struct A309_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A309_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A309_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A309_extra_packed) == 1, "");
_Static_assert(sizeof(struct A309_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_size) == 10, "");
_Static_assert(_Alignof(struct A309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A309,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A309,e) == 3, "");
#endif
_Static_assert(sizeof(A310) == 16, "");
_Static_assert(_Alignof(A310) == 8, "");
_Static_assert(sizeof(struct A310_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A310_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A310_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A310_extra_packed) == 1, "");
_Static_assert(sizeof(struct A310_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A310_extra_size) == 18, "");
_Static_assert(_Alignof(struct A310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A310,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(A310,e) == 127, "");
#endif
_Static_assert(sizeof(A311) == 9, "");
_Static_assert(_Alignof(A311) == 1, "");
_Static_assert(sizeof(struct A311_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A311_extra_packed) == 1, "");
_Static_assert(sizeof(struct A311_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_size) == 11, "");
_Static_assert(_Alignof(struct A311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A311,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A311,e) == 65, "");
#endif
_Static_assert(sizeof(A312) == 10, "");
_Static_assert(_Alignof(A312) == 2, "");
_Static_assert(sizeof(struct A312_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A312_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A312_extra_packed) == 1, "");
_Static_assert(sizeof(struct A312_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A312_extra_size) == 12, "");
_Static_assert(_Alignof(struct A312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A312,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A312,e) == 65, "");
#endif
_Static_assert(sizeof(A313) == 12, "");
_Static_assert(_Alignof(A313) == 4, "");
_Static_assert(sizeof(struct A313_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A313_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A313_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A313_extra_packed) == 1, "");
_Static_assert(sizeof(struct A313_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A313_extra_size) == 14, "");
_Static_assert(_Alignof(struct A313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A313,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A313,e) == 65, "");
#endif
_Static_assert(sizeof(A314) == 16, "");
_Static_assert(_Alignof(A314) == 8, "");
_Static_assert(sizeof(struct A314_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A314_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A314_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A314_extra_packed) == 1, "");
_Static_assert(sizeof(struct A314_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A314_extra_size) == 18, "");
_Static_assert(_Alignof(struct A314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A314,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A314,e) == 65, "");
#endif
_Static_assert(sizeof(A315) == 9, "");
_Static_assert(_Alignof(A315) == 1, "");
_Static_assert(sizeof(struct A315_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A315_extra_packed) == 1, "");
_Static_assert(sizeof(struct A315_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_size) == 11, "");
_Static_assert(_Alignof(struct A315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A315,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A315,e) == 65, "");
#endif
_Static_assert(sizeof(A316) == 9, "");
_Static_assert(_Alignof(A316) == 1, "");
_Static_assert(sizeof(struct A316_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A316_extra_packed) == 1, "");
_Static_assert(sizeof(struct A316_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_size) == 11, "");
_Static_assert(_Alignof(struct A316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A316,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A316,e) == 65, "");
#endif
_Static_assert(sizeof(A317) == 10, "");
_Static_assert(_Alignof(A317) == 2, "");
_Static_assert(sizeof(struct A317_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A317_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A317_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A317_extra_packed) == 1, "");
_Static_assert(sizeof(struct A317_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_size) == 12, "");
_Static_assert(_Alignof(struct A317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A317,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A317,e) == 65, "");
#endif
_Static_assert(sizeof(A318) == 12, "");
_Static_assert(_Alignof(A318) == 4, "");
_Static_assert(sizeof(struct A318_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A318_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A318_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A318_extra_packed) == 1, "");
_Static_assert(sizeof(struct A318_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_size) == 14, "");
_Static_assert(_Alignof(struct A318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A318,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A318,e) == 65, "");
#endif
_Static_assert(sizeof(A319) == 16, "");
_Static_assert(_Alignof(A319) == 8, "");
_Static_assert(sizeof(struct A319_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A319_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A319_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A319_extra_packed) == 1, "");
_Static_assert(sizeof(struct A319_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_size) == 18, "");
_Static_assert(_Alignof(struct A319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A319,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A319,e) == 65, "");
#endif
_Static_assert(sizeof(A410) == 16, "");
_Static_assert(_Alignof(A410) == 8, "");
_Static_assert(sizeof(struct A410_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A410_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A410_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A410_extra_packed) == 1, "");
_Static_assert(sizeof(struct A410_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A410_extra_size) == 18, "");
_Static_assert(_Alignof(struct A410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A410,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(A410,e) == 126, "");
#endif
_Static_assert(sizeof(A411) == 9, "");
_Static_assert(_Alignof(A411) == 1, "");
_Static_assert(sizeof(struct A411_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A411_extra_packed) == 1, "");
_Static_assert(sizeof(struct A411_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_size) == 11, "");
_Static_assert(_Alignof(struct A411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A411,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A411,e) == 70, "");
#endif
_Static_assert(sizeof(A412) == 10, "");
_Static_assert(_Alignof(A412) == 2, "");
_Static_assert(sizeof(struct A412_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A412_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A412_extra_packed) == 1, "");
_Static_assert(sizeof(struct A412_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A412_extra_size) == 12, "");
_Static_assert(_Alignof(struct A412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A412,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A412,e) == 78, "");
#endif
_Static_assert(sizeof(A413) == 12, "");
_Static_assert(_Alignof(A413) == 4, "");
_Static_assert(sizeof(struct A413_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A413_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A413_extra_packed) == 1, "");
_Static_assert(sizeof(struct A413_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A413_extra_size) == 14, "");
_Static_assert(_Alignof(struct A413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A413,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A413,e) == 94, "");
#endif
_Static_assert(sizeof(A414) == 16, "");
_Static_assert(_Alignof(A414) == 8, "");
_Static_assert(sizeof(struct A414_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A414_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A414_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A414_extra_packed) == 1, "");
_Static_assert(sizeof(struct A414_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A414_extra_size) == 18, "");
_Static_assert(_Alignof(struct A414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A414,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A414,e) == 94, "");
#endif
_Static_assert(sizeof(A415) == 10, "");
_Static_assert(_Alignof(A415) == 2, "");
_Static_assert(sizeof(struct A415_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A415_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A415_extra_packed) == 1, "");
_Static_assert(sizeof(struct A415_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A415_extra_size) == 12, "");
_Static_assert(_Alignof(struct A415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A415,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A415,e) == 78, "");
#endif
_Static_assert(sizeof(A416) == 9, "");
_Static_assert(_Alignof(A416) == 1, "");
_Static_assert(sizeof(struct A416_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A416_extra_packed) == 1, "");
_Static_assert(sizeof(struct A416_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_size) == 11, "");
_Static_assert(_Alignof(struct A416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A416,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A416,e) == 70, "");
#endif
_Static_assert(sizeof(A417) == 10, "");
_Static_assert(_Alignof(A417) == 2, "");
_Static_assert(sizeof(struct A417_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A417_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A417_extra_packed) == 1, "");
_Static_assert(sizeof(struct A417_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A417_extra_size) == 12, "");
_Static_assert(_Alignof(struct A417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A417,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A417,e) == 78, "");
#endif
_Static_assert(sizeof(A418) == 12, "");
_Static_assert(_Alignof(A418) == 4, "");
_Static_assert(sizeof(struct A418_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A418_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A418_extra_packed) == 1, "");
_Static_assert(sizeof(struct A418_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A418_extra_size) == 14, "");
_Static_assert(_Alignof(struct A418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A418,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A418,e) == 94, "");
#endif
_Static_assert(sizeof(A419) == 16, "");
_Static_assert(_Alignof(A419) == 8, "");
_Static_assert(sizeof(struct A419_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A419_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A419_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A419_extra_packed) == 1, "");
_Static_assert(sizeof(struct A419_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A419_extra_size) == 18, "");
_Static_assert(_Alignof(struct A419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A419,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A419,e) == 94, "");
#endif
_Static_assert(sizeof(A510) == 16, "");
_Static_assert(_Alignof(A510) == 8, "");
_Static_assert(sizeof(struct A510_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A510_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A510_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A510_extra_packed) == 1, "");
_Static_assert(sizeof(struct A510_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A510_extra_size) == 18, "");
_Static_assert(_Alignof(struct A510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A510,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A510,e) == 64, "");
#endif
_Static_assert(sizeof(A511) == 9, "");
_Static_assert(_Alignof(A511) == 1, "");
_Static_assert(sizeof(struct A511_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A511_extra_packed) == 1, "");
_Static_assert(sizeof(struct A511_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_size) == 11, "");
_Static_assert(_Alignof(struct A511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A511,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A511,e) == 64, "");
#endif
_Static_assert(sizeof(A512) == 10, "");
_Static_assert(_Alignof(A512) == 2, "");
_Static_assert(sizeof(struct A512_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A512_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A512_extra_packed) == 1, "");
_Static_assert(sizeof(struct A512_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A512_extra_size) == 12, "");
_Static_assert(_Alignof(struct A512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A512,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A512,e) == 64, "");
#endif
_Static_assert(sizeof(A513) == 12, "");
_Static_assert(_Alignof(A513) == 4, "");
_Static_assert(sizeof(struct A513_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A513_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A513_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A513_extra_packed) == 1, "");
_Static_assert(sizeof(struct A513_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A513_extra_size) == 14, "");
_Static_assert(_Alignof(struct A513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A513,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A513,e) == 64, "");
#endif
_Static_assert(sizeof(A514) == 16, "");
_Static_assert(_Alignof(A514) == 8, "");
_Static_assert(sizeof(struct A514_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A514_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A514_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A514_extra_packed) == 1, "");
_Static_assert(sizeof(struct A514_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A514_extra_size) == 18, "");
_Static_assert(_Alignof(struct A514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A514,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A514,e) == 64, "");
#endif
_Static_assert(sizeof(A515) == 9, "");
_Static_assert(_Alignof(A515) == 1, "");
_Static_assert(sizeof(struct A515_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A515_extra_packed) == 1, "");
_Static_assert(sizeof(struct A515_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_size) == 11, "");
_Static_assert(_Alignof(struct A515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A515,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A515,e) == 64, "");
#endif
_Static_assert(sizeof(A516) == 9, "");
_Static_assert(_Alignof(A516) == 1, "");
_Static_assert(sizeof(struct A516_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A516_extra_packed) == 1, "");
_Static_assert(sizeof(struct A516_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_size) == 11, "");
_Static_assert(_Alignof(struct A516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A516,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A516,e) == 64, "");
#endif
_Static_assert(sizeof(A517) == 10, "");
_Static_assert(_Alignof(A517) == 2, "");
_Static_assert(sizeof(struct A517_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A517_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A517_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A517_extra_packed) == 1, "");
_Static_assert(sizeof(struct A517_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_size) == 12, "");
_Static_assert(_Alignof(struct A517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A517,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A517,e) == 64, "");
#endif
_Static_assert(sizeof(A518) == 12, "");
_Static_assert(_Alignof(A518) == 4, "");
_Static_assert(sizeof(struct A518_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A518_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A518_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A518_extra_packed) == 1, "");
_Static_assert(sizeof(struct A518_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_size) == 14, "");
_Static_assert(_Alignof(struct A518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A518,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A518,e) == 64, "");
#endif
_Static_assert(sizeof(A519) == 16, "");
_Static_assert(_Alignof(A519) == 8, "");
_Static_assert(sizeof(struct A519_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A519_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A519_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A519_extra_packed) == 1, "");
_Static_assert(sizeof(struct A519_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_size) == 18, "");
_Static_assert(_Alignof(struct A519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A519,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A519,e) == 64, "");
#endif
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 2, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B000,e) == 0, "");
#endif
_Static_assert(sizeof(B001) == 1, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 3, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B001,e) == 0, "");
#endif
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 2, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B002,e) == 0, "");
#endif
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 4, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B003,e) == 0, "");
#endif
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 4, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B004,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B004,e) == 0, "");
#endif
_Static_assert(sizeof(B005) == 2, "");
_Static_assert(_Alignof(B005) == 2, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B005_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 4, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B005,e) == 0, "");
#endif
_Static_assert(sizeof(B006) == 1, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 3, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B006,e) == 0, "");
#endif
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 2, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B007,e) == 0, "");
#endif
_Static_assert(sizeof(B008) == 4, "");
_Static_assert(_Alignof(B008) == 4, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B008_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 6, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B008,e) == 0, "");
#endif
_Static_assert(sizeof(B009) == 4, "");
_Static_assert(_Alignof(B009) == 4, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B009_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 6, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B009,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B009,e) == 0, "");
#endif
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 2, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B010,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B010,e) == 0, "");
#endif
_Static_assert(sizeof(B011) == 1, "");
_Static_assert(_Alignof(B011) == 1, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 3, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B011,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B011,e) == 0, "");
#endif
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 2, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B012,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B012,e) == 0, "");
#endif
_Static_assert(sizeof(B013) == 4, "");
_Static_assert(_Alignof(B013) == 4, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B013_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 6, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B013,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B013,e) == 0, "");
#endif
_Static_assert(sizeof(B014) == 4, "");
_Static_assert(_Alignof(B014) == 4, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B014_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 6, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B014,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B014,e) == 0, "");
#endif
_Static_assert(sizeof(B015) == 2, "");
_Static_assert(_Alignof(B015) == 2, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 4, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B015,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B015,e) == 0, "");
#endif
_Static_assert(sizeof(B016) == 1, "");
_Static_assert(_Alignof(B016) == 1, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 3, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B016,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B016,e) == 0, "");
#endif
_Static_assert(sizeof(B017) == 2, "");
_Static_assert(_Alignof(B017) == 2, "");
_Static_assert(sizeof(struct B017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B017_extra_packed) == 1, "");
_Static_assert(sizeof(struct B017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B017_extra_size) == 4, "");
_Static_assert(_Alignof(struct B017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B017,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B017,e) == 0, "");
#endif
_Static_assert(sizeof(B018) == 4, "");
_Static_assert(_Alignof(B018) == 4, "");
_Static_assert(sizeof(struct B018_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B018_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B018_extra_packed) == 1, "");
_Static_assert(sizeof(struct B018_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B018_extra_size) == 6, "");
_Static_assert(_Alignof(struct B018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B018,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B018,e) == 0, "");
#endif
_Static_assert(sizeof(B019) == 4, "");
_Static_assert(_Alignof(B019) == 4, "");
_Static_assert(sizeof(struct B019_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B019_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B019_extra_packed) == 1, "");
_Static_assert(sizeof(struct B019_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B019_extra_size) == 6, "");
_Static_assert(_Alignof(struct B019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B019,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B019,e) == 0, "");
#endif
_Static_assert(sizeof(B100) == 8, "");
_Static_assert(_Alignof(B100) == 8, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B100_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 10, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B100,e) == 0, "");
#endif
_Static_assert(sizeof(B101) == 1, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 3, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B101,e) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B102,e) == 0, "");
#endif
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B103,e) == 0, "");
#endif
_Static_assert(sizeof(B104) == 8, "");
_Static_assert(_Alignof(B104) == 8, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B104_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 10, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B104,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B104,e) == 0, "");
#endif
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B105,e) == 0, "");
#endif
_Static_assert(sizeof(B106) == 1, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 3, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B106,e) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B107,e) == 0, "");
#endif
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 4, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B108,e) == 0, "");
#endif
_Static_assert(sizeof(B109) == 8, "");
_Static_assert(_Alignof(B109) == 8, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B109_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 10, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B109,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B109,e) == 0, "");
#endif
_Static_assert(sizeof(B110) == 8, "");
_Static_assert(_Alignof(B110) == 8, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B110_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 10, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B110,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B110,e) == 0, "");
#endif
_Static_assert(sizeof(B111) == 8, "");
_Static_assert(_Alignof(B111) == 1, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 10, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B111,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B111,e) == 0, "");
#endif
_Static_assert(sizeof(B112) == 8, "");
_Static_assert(_Alignof(B112) == 2, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B112_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 10, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B112,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B112,e) == 0, "");
#endif
_Static_assert(sizeof(B113) == 8, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 10, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B113,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B113,e) == 0, "");
#endif
_Static_assert(sizeof(B114) == 8, "");
_Static_assert(_Alignof(B114) == 8, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B114_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 10, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B114,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B114,e) == 0, "");
#endif
_Static_assert(sizeof(B115) == 8, "");
_Static_assert(_Alignof(B115) == 2, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B115_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 10, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B115,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B115,e) == 0, "");
#endif
_Static_assert(sizeof(B116) == 8, "");
_Static_assert(_Alignof(B116) == 1, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 10, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B116,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B116,e) == 0, "");
#endif
_Static_assert(sizeof(B117) == 8, "");
_Static_assert(_Alignof(B117) == 2, "");
_Static_assert(sizeof(struct B117_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B117_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B117_extra_packed) == 1, "");
_Static_assert(sizeof(struct B117_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B117_extra_size) == 10, "");
_Static_assert(_Alignof(struct B117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B117,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B117,e) == 0, "");
#endif
_Static_assert(sizeof(B118) == 8, "");
_Static_assert(_Alignof(B118) == 4, "");
_Static_assert(sizeof(struct B118_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B118_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B118_extra_packed) == 1, "");
_Static_assert(sizeof(struct B118_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B118_extra_size) == 10, "");
_Static_assert(_Alignof(struct B118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B118,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B118,e) == 0, "");
#endif
_Static_assert(sizeof(B119) == 8, "");
_Static_assert(_Alignof(B119) == 8, "");
_Static_assert(sizeof(struct B119_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B119_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B119_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B119_extra_packed) == 1, "");
_Static_assert(sizeof(struct B119_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B119_extra_size) == 10, "");
_Static_assert(_Alignof(struct B119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B119,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B119,e) == 0, "");
#endif
_Static_assert(sizeof(B200) == 1, "");
_Static_assert(_Alignof(B200) == 1, "");
_Static_assert(sizeof(struct B200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B200_extra_packed) == 1, "");
_Static_assert(sizeof(struct B200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_size) == 3, "");
_Static_assert(_Alignof(struct B200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B200,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B200,e) == 0, "");
#endif
_Static_assert(sizeof(B201) == 1, "");
_Static_assert(_Alignof(B201) == 1, "");
_Static_assert(sizeof(struct B201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B201_extra_packed) == 1, "");
_Static_assert(sizeof(struct B201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_size) == 3, "");
_Static_assert(_Alignof(struct B201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B201,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B201,e) == 0, "");
#endif
_Static_assert(sizeof(B202) == 1, "");
_Static_assert(_Alignof(B202) == 1, "");
_Static_assert(sizeof(struct B202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B202_extra_packed) == 1, "");
_Static_assert(sizeof(struct B202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_size) == 3, "");
_Static_assert(_Alignof(struct B202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B202,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B202,e) == 0, "");
#endif
_Static_assert(sizeof(B203) == 1, "");
_Static_assert(_Alignof(B203) == 1, "");
_Static_assert(sizeof(struct B203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B203_extra_packed) == 1, "");
_Static_assert(sizeof(struct B203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_size) == 3, "");
_Static_assert(_Alignof(struct B203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B203,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B203,e) == 0, "");
#endif
_Static_assert(sizeof(B204) == 1, "");
_Static_assert(_Alignof(B204) == 1, "");
_Static_assert(sizeof(struct B204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B204_extra_packed) == 1, "");
_Static_assert(sizeof(struct B204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_size) == 3, "");
_Static_assert(_Alignof(struct B204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B204,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B204,e) == 0, "");
#endif
_Static_assert(sizeof(B205) == 1, "");
_Static_assert(_Alignof(B205) == 1, "");
_Static_assert(sizeof(struct B205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B205_extra_packed) == 1, "");
_Static_assert(sizeof(struct B205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_size) == 3, "");
_Static_assert(_Alignof(struct B205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B205,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B205,e) == 0, "");
#endif
_Static_assert(sizeof(B206) == 1, "");
_Static_assert(_Alignof(B206) == 1, "");
_Static_assert(sizeof(struct B206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B206_extra_packed) == 1, "");
_Static_assert(sizeof(struct B206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_size) == 3, "");
_Static_assert(_Alignof(struct B206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B206,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B206,e) == 0, "");
#endif
_Static_assert(sizeof(B207) == 1, "");
_Static_assert(_Alignof(B207) == 1, "");
_Static_assert(sizeof(struct B207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B207_extra_packed) == 1, "");
_Static_assert(sizeof(struct B207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_size) == 3, "");
_Static_assert(_Alignof(struct B207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B207,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B207,e) == 0, "");
#endif
_Static_assert(sizeof(B208) == 1, "");
_Static_assert(_Alignof(B208) == 1, "");
_Static_assert(sizeof(struct B208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B208_extra_packed) == 1, "");
_Static_assert(sizeof(struct B208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_size) == 3, "");
_Static_assert(_Alignof(struct B208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B208,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B208,e) == 0, "");
#endif
_Static_assert(sizeof(B209) == 1, "");
_Static_assert(_Alignof(B209) == 1, "");
_Static_assert(sizeof(struct B209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B209_extra_packed) == 1, "");
_Static_assert(sizeof(struct B209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_size) == 3, "");
_Static_assert(_Alignof(struct B209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B209,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B209,e) == 0, "");
#endif
_Static_assert(sizeof(B210) == 1, "");
_Static_assert(_Alignof(B210) == 1, "");
_Static_assert(sizeof(struct B210_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B210_extra_packed) == 1, "");
_Static_assert(sizeof(struct B210_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_size) == 3, "");
_Static_assert(_Alignof(struct B210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B210,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B210,e) == 0, "");
#endif
_Static_assert(sizeof(B211) == 1, "");
_Static_assert(_Alignof(B211) == 1, "");
_Static_assert(sizeof(struct B211_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B211_extra_packed) == 1, "");
_Static_assert(sizeof(struct B211_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_size) == 3, "");
_Static_assert(_Alignof(struct B211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B211,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B211,e) == 0, "");
#endif
_Static_assert(sizeof(B212) == 1, "");
_Static_assert(_Alignof(B212) == 1, "");
_Static_assert(sizeof(struct B212_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B212_extra_packed) == 1, "");
_Static_assert(sizeof(struct B212_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_size) == 3, "");
_Static_assert(_Alignof(struct B212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B212,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B212,e) == 0, "");
#endif
_Static_assert(sizeof(B213) == 1, "");
_Static_assert(_Alignof(B213) == 1, "");
_Static_assert(sizeof(struct B213_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B213_extra_packed) == 1, "");
_Static_assert(sizeof(struct B213_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_size) == 3, "");
_Static_assert(_Alignof(struct B213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B213,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B213,e) == 0, "");
#endif
_Static_assert(sizeof(B214) == 1, "");
_Static_assert(_Alignof(B214) == 1, "");
_Static_assert(sizeof(struct B214_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B214_extra_packed) == 1, "");
_Static_assert(sizeof(struct B214_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_size) == 3, "");
_Static_assert(_Alignof(struct B214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B214,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B214,e) == 0, "");
#endif
_Static_assert(sizeof(B215) == 1, "");
_Static_assert(_Alignof(B215) == 1, "");
_Static_assert(sizeof(struct B215_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B215_extra_packed) == 1, "");
_Static_assert(sizeof(struct B215_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_size) == 3, "");
_Static_assert(_Alignof(struct B215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B215,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B215,e) == 0, "");
#endif
_Static_assert(sizeof(B216) == 1, "");
_Static_assert(_Alignof(B216) == 1, "");
_Static_assert(sizeof(struct B216_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B216_extra_packed) == 1, "");
_Static_assert(sizeof(struct B216_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_size) == 3, "");
_Static_assert(_Alignof(struct B216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B216,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B216,e) == 0, "");
#endif
_Static_assert(sizeof(B217) == 1, "");
_Static_assert(_Alignof(B217) == 1, "");
_Static_assert(sizeof(struct B217_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B217_extra_packed) == 1, "");
_Static_assert(sizeof(struct B217_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_size) == 3, "");
_Static_assert(_Alignof(struct B217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B217,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B217,e) == 0, "");
#endif
_Static_assert(sizeof(B218) == 1, "");
_Static_assert(_Alignof(B218) == 1, "");
_Static_assert(sizeof(struct B218_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B218_extra_packed) == 1, "");
_Static_assert(sizeof(struct B218_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_size) == 3, "");
_Static_assert(_Alignof(struct B218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B218,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B218,e) == 0, "");
#endif
_Static_assert(sizeof(B219) == 1, "");
_Static_assert(_Alignof(B219) == 1, "");
_Static_assert(sizeof(struct B219_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B219_extra_packed) == 1, "");
_Static_assert(sizeof(struct B219_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_size) == 3, "");
_Static_assert(_Alignof(struct B219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B219,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B219,e) == 0, "");
#endif
_Static_assert(sizeof(B300) == 8, "");
_Static_assert(_Alignof(B300) == 8, "");
_Static_assert(sizeof(struct B300_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B300_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B300_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B300_extra_packed) == 1, "");
_Static_assert(sizeof(struct B300_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B300_extra_size) == 10, "");
_Static_assert(_Alignof(struct B300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B300,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B300,e) == 0, "");
#endif
_Static_assert(sizeof(B301) == 1, "");
_Static_assert(_Alignof(B301) == 1, "");
_Static_assert(sizeof(struct B301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B301_extra_packed) == 1, "");
_Static_assert(sizeof(struct B301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_size) == 3, "");
_Static_assert(_Alignof(struct B301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B301,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B301,e) == 0, "");
#endif
_Static_assert(sizeof(B302) == 2, "");
_Static_assert(_Alignof(B302) == 2, "");
_Static_assert(sizeof(struct B302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B302_extra_packed) == 1, "");
_Static_assert(sizeof(struct B302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B302_extra_size) == 4, "");
_Static_assert(_Alignof(struct B302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B302,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B302,e) == 0, "");
#endif
_Static_assert(sizeof(B303) == 4, "");
_Static_assert(_Alignof(B303) == 4, "");
_Static_assert(sizeof(struct B303_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B303_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B303_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B303_extra_packed) == 1, "");
_Static_assert(sizeof(struct B303_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B303_extra_size) == 6, "");
_Static_assert(_Alignof(struct B303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B303,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B303,e) == 0, "");
#endif
_Static_assert(sizeof(B304) == 8, "");
_Static_assert(_Alignof(B304) == 8, "");
_Static_assert(sizeof(struct B304_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B304_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B304_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B304_extra_packed) == 1, "");
_Static_assert(sizeof(struct B304_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B304_extra_size) == 10, "");
_Static_assert(_Alignof(struct B304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B304,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B304,e) == 0, "");
#endif
_Static_assert(sizeof(B305) == 1, "");
_Static_assert(_Alignof(B305) == 1, "");
_Static_assert(sizeof(struct B305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B305_extra_packed) == 1, "");
_Static_assert(sizeof(struct B305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_size) == 3, "");
_Static_assert(_Alignof(struct B305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B305,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B305,e) == 0, "");
#endif
_Static_assert(sizeof(B306) == 1, "");
_Static_assert(_Alignof(B306) == 1, "");
_Static_assert(sizeof(struct B306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B306_extra_packed) == 1, "");
_Static_assert(sizeof(struct B306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_size) == 3, "");
_Static_assert(_Alignof(struct B306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B306,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B306,e) == 0, "");
#endif
_Static_assert(sizeof(B307) == 2, "");
_Static_assert(_Alignof(B307) == 2, "");
_Static_assert(sizeof(struct B307_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B307_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B307_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B307_extra_packed) == 1, "");
_Static_assert(sizeof(struct B307_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_size) == 4, "");
_Static_assert(_Alignof(struct B307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B307,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B307,e) == 0, "");
#endif
_Static_assert(sizeof(B308) == 4, "");
_Static_assert(_Alignof(B308) == 4, "");
_Static_assert(sizeof(struct B308_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B308_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B308_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B308_extra_packed) == 1, "");
_Static_assert(sizeof(struct B308_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_size) == 6, "");
_Static_assert(_Alignof(struct B308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B308,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B308,e) == 0, "");
#endif
_Static_assert(sizeof(B309) == 8, "");
_Static_assert(_Alignof(B309) == 8, "");
_Static_assert(sizeof(struct B309_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B309_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B309_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B309_extra_packed) == 1, "");
_Static_assert(sizeof(struct B309_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_size) == 10, "");
_Static_assert(_Alignof(struct B309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B309,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B309,e) == 0, "");
#endif
_Static_assert(sizeof(B310) == 8, "");
_Static_assert(_Alignof(B310) == 8, "");
_Static_assert(sizeof(struct B310_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B310_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B310_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B310_extra_packed) == 1, "");
_Static_assert(sizeof(struct B310_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B310_extra_size) == 10, "");
_Static_assert(_Alignof(struct B310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B310,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B310,e) == 0, "");
#endif
_Static_assert(sizeof(B311) == 8, "");
_Static_assert(_Alignof(B311) == 1, "");
_Static_assert(sizeof(struct B311_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B311_extra_packed) == 1, "");
_Static_assert(sizeof(struct B311_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_size) == 10, "");
_Static_assert(_Alignof(struct B311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B311,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B311,e) == 0, "");
#endif
_Static_assert(sizeof(B312) == 8, "");
_Static_assert(_Alignof(B312) == 2, "");
_Static_assert(sizeof(struct B312_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B312_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B312_extra_packed) == 1, "");
_Static_assert(sizeof(struct B312_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B312_extra_size) == 10, "");
_Static_assert(_Alignof(struct B312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B312,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B312,e) == 0, "");
#endif
_Static_assert(sizeof(B313) == 8, "");
_Static_assert(_Alignof(B313) == 4, "");
_Static_assert(sizeof(struct B313_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B313_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B313_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B313_extra_packed) == 1, "");
_Static_assert(sizeof(struct B313_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B313_extra_size) == 10, "");
_Static_assert(_Alignof(struct B313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B313,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B313,e) == 0, "");
#endif
_Static_assert(sizeof(B314) == 8, "");
_Static_assert(_Alignof(B314) == 8, "");
_Static_assert(sizeof(struct B314_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B314_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B314_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B314_extra_packed) == 1, "");
_Static_assert(sizeof(struct B314_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B314_extra_size) == 10, "");
_Static_assert(_Alignof(struct B314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B314,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B314,e) == 0, "");
#endif
_Static_assert(sizeof(B315) == 8, "");
_Static_assert(_Alignof(B315) == 1, "");
_Static_assert(sizeof(struct B315_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B315_extra_packed) == 1, "");
_Static_assert(sizeof(struct B315_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_size) == 10, "");
_Static_assert(_Alignof(struct B315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B315,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B315,e) == 0, "");
#endif
_Static_assert(sizeof(B316) == 8, "");
_Static_assert(_Alignof(B316) == 1, "");
_Static_assert(sizeof(struct B316_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B316_extra_packed) == 1, "");
_Static_assert(sizeof(struct B316_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_size) == 10, "");
_Static_assert(_Alignof(struct B316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B316,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B316,e) == 0, "");
#endif
_Static_assert(sizeof(B317) == 8, "");
_Static_assert(_Alignof(B317) == 2, "");
_Static_assert(sizeof(struct B317_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B317_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B317_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B317_extra_packed) == 1, "");
_Static_assert(sizeof(struct B317_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_size) == 10, "");
_Static_assert(_Alignof(struct B317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B317,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B317,e) == 0, "");
#endif
_Static_assert(sizeof(B318) == 8, "");
_Static_assert(_Alignof(B318) == 4, "");
_Static_assert(sizeof(struct B318_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B318_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B318_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B318_extra_packed) == 1, "");
_Static_assert(sizeof(struct B318_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_size) == 10, "");
_Static_assert(_Alignof(struct B318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B318,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B318,e) == 0, "");
#endif
_Static_assert(sizeof(B319) == 8, "");
_Static_assert(_Alignof(B319) == 8, "");
_Static_assert(sizeof(struct B319_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B319_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B319_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B319_extra_packed) == 1, "");
_Static_assert(sizeof(struct B319_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_size) == 10, "");
_Static_assert(_Alignof(struct B319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B319,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B319,e) == 0, "");
#endif
_Static_assert(sizeof(B410) == 8, "");
_Static_assert(_Alignof(B410) == 8, "");
_Static_assert(sizeof(struct B410_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B410_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B410_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B410_extra_packed) == 1, "");
_Static_assert(sizeof(struct B410_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B410_extra_size) == 10, "");
_Static_assert(_Alignof(struct B410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B410,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B410,e) == 0, "");
#endif
_Static_assert(sizeof(B411) == 8, "");
_Static_assert(_Alignof(B411) == 1, "");
_Static_assert(sizeof(struct B411_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B411_extra_packed) == 1, "");
_Static_assert(sizeof(struct B411_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_size) == 10, "");
_Static_assert(_Alignof(struct B411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B411,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B411,e) == 0, "");
#endif
_Static_assert(sizeof(B412) == 8, "");
_Static_assert(_Alignof(B412) == 2, "");
_Static_assert(sizeof(struct B412_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B412_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B412_extra_packed) == 1, "");
_Static_assert(sizeof(struct B412_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B412_extra_size) == 10, "");
_Static_assert(_Alignof(struct B412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B412,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B412,e) == 0, "");
#endif
_Static_assert(sizeof(B413) == 8, "");
_Static_assert(_Alignof(B413) == 4, "");
_Static_assert(sizeof(struct B413_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B413_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B413_extra_packed) == 1, "");
_Static_assert(sizeof(struct B413_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B413_extra_size) == 10, "");
_Static_assert(_Alignof(struct B413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B413,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B413,e) == 0, "");
#endif
_Static_assert(sizeof(B414) == 8, "");
_Static_assert(_Alignof(B414) == 8, "");
_Static_assert(sizeof(struct B414_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B414_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B414_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B414_extra_packed) == 1, "");
_Static_assert(sizeof(struct B414_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B414_extra_size) == 10, "");
_Static_assert(_Alignof(struct B414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B414,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B414,e) == 0, "");
#endif
_Static_assert(sizeof(B415) == 8, "");
_Static_assert(_Alignof(B415) == 2, "");
_Static_assert(sizeof(struct B415_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B415_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B415_extra_packed) == 1, "");
_Static_assert(sizeof(struct B415_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B415_extra_size) == 10, "");
_Static_assert(_Alignof(struct B415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B415,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B415,e) == 0, "");
#endif
_Static_assert(sizeof(B416) == 8, "");
_Static_assert(_Alignof(B416) == 1, "");
_Static_assert(sizeof(struct B416_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B416_extra_packed) == 1, "");
_Static_assert(sizeof(struct B416_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_size) == 10, "");
_Static_assert(_Alignof(struct B416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B416,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B416,e) == 0, "");
#endif
_Static_assert(sizeof(B417) == 8, "");
_Static_assert(_Alignof(B417) == 2, "");
_Static_assert(sizeof(struct B417_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B417_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B417_extra_packed) == 1, "");
_Static_assert(sizeof(struct B417_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B417_extra_size) == 10, "");
_Static_assert(_Alignof(struct B417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B417,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B417,e) == 0, "");
#endif
_Static_assert(sizeof(B418) == 8, "");
_Static_assert(_Alignof(B418) == 4, "");
_Static_assert(sizeof(struct B418_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B418_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B418_extra_packed) == 1, "");
_Static_assert(sizeof(struct B418_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B418_extra_size) == 10, "");
_Static_assert(_Alignof(struct B418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B418,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B418,e) == 0, "");
#endif
_Static_assert(sizeof(B419) == 8, "");
_Static_assert(_Alignof(B419) == 8, "");
_Static_assert(sizeof(struct B419_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B419_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B419_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B419_extra_packed) == 1, "");
_Static_assert(sizeof(struct B419_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B419_extra_size) == 10, "");
_Static_assert(_Alignof(struct B419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B419,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B419,e) == 0, "");
#endif
_Static_assert(sizeof(B510) == 8, "");
_Static_assert(_Alignof(B510) == 8, "");
_Static_assert(sizeof(struct B510_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B510_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B510_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B510_extra_packed) == 1, "");
_Static_assert(sizeof(struct B510_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B510_extra_size) == 10, "");
_Static_assert(_Alignof(struct B510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B510,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B510,e) == 0, "");
#endif
_Static_assert(sizeof(B511) == 8, "");
_Static_assert(_Alignof(B511) == 1, "");
_Static_assert(sizeof(struct B511_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B511_extra_packed) == 1, "");
_Static_assert(sizeof(struct B511_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_size) == 10, "");
_Static_assert(_Alignof(struct B511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B511,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B511,e) == 0, "");
#endif
_Static_assert(sizeof(B512) == 8, "");
_Static_assert(_Alignof(B512) == 2, "");
_Static_assert(sizeof(struct B512_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B512_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B512_extra_packed) == 1, "");
_Static_assert(sizeof(struct B512_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B512_extra_size) == 10, "");
_Static_assert(_Alignof(struct B512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B512,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B512,e) == 0, "");
#endif
_Static_assert(sizeof(B513) == 8, "");
_Static_assert(_Alignof(B513) == 4, "");
_Static_assert(sizeof(struct B513_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B513_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B513_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B513_extra_packed) == 1, "");
_Static_assert(sizeof(struct B513_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B513_extra_size) == 10, "");
_Static_assert(_Alignof(struct B513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B513,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B513,e) == 0, "");
#endif
_Static_assert(sizeof(B514) == 8, "");
_Static_assert(_Alignof(B514) == 8, "");
_Static_assert(sizeof(struct B514_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B514_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B514_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B514_extra_packed) == 1, "");
_Static_assert(sizeof(struct B514_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B514_extra_size) == 10, "");
_Static_assert(_Alignof(struct B514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B514,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B514,e) == 0, "");
#endif
_Static_assert(sizeof(B515) == 8, "");
_Static_assert(_Alignof(B515) == 1, "");
_Static_assert(sizeof(struct B515_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B515_extra_packed) == 1, "");
_Static_assert(sizeof(struct B515_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_size) == 10, "");
_Static_assert(_Alignof(struct B515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B515,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B515,e) == 0, "");
#endif
_Static_assert(sizeof(B516) == 8, "");
_Static_assert(_Alignof(B516) == 1, "");
_Static_assert(sizeof(struct B516_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B516_extra_packed) == 1, "");
_Static_assert(sizeof(struct B516_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_size) == 10, "");
_Static_assert(_Alignof(struct B516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B516,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B516,e) == 0, "");
#endif
_Static_assert(sizeof(B517) == 8, "");
_Static_assert(_Alignof(B517) == 2, "");
_Static_assert(sizeof(struct B517_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B517_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B517_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B517_extra_packed) == 1, "");
_Static_assert(sizeof(struct B517_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_size) == 10, "");
_Static_assert(_Alignof(struct B517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B517,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B517,e) == 0, "");
#endif
_Static_assert(sizeof(B518) == 8, "");
_Static_assert(_Alignof(B518) == 4, "");
_Static_assert(sizeof(struct B518_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B518_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B518_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B518_extra_packed) == 1, "");
_Static_assert(sizeof(struct B518_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_size) == 10, "");
_Static_assert(_Alignof(struct B518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B518,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B518,e) == 0, "");
#endif
_Static_assert(sizeof(B519) == 8, "");
_Static_assert(_Alignof(B519) == 8, "");
_Static_assert(sizeof(struct B519_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B519_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B519_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B519_extra_packed) == 1, "");
_Static_assert(sizeof(struct B519_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_size) == 10, "");
_Static_assert(_Alignof(struct B519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B519,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B519,e) == 0, "");
#endif
// MAPPING|THREE|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-other-none:Clang|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|END
// repr targets Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownNone|Some("mipsel-mips32-other-none") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl")
#elif defined(THREE)
_Static_assert(sizeof(A000) == 4, "");
_Static_assert(_Alignof(A000) == 2, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 6, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A000,e) == 17, "");
#endif
_Static_assert(sizeof(A001) == 1, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 3, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A001,e) == 2, "");
#endif
_Static_assert(sizeof(A002) == 2, "");
_Static_assert(_Alignof(A002) == 2, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 4, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A002,e) == 2, "");
#endif
_Static_assert(sizeof(A003) == 8, "");
_Static_assert(_Alignof(A003) == 4, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A003_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 10, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A003,e) == 33, "");
#endif
_Static_assert(sizeof(A004) == 8, "");
_Static_assert(_Alignof(A004) == 4, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A004_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 10, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A004,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A004,e) == 33, "");
#endif
_Static_assert(sizeof(A005) == 4, "");
_Static_assert(_Alignof(A005) == 2, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A005_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 6, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A005,e) == 17, "");
#endif
_Static_assert(sizeof(A006) == 1, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 3, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A006,e) == 2, "");
#endif
_Static_assert(sizeof(A007) == 2, "");
_Static_assert(_Alignof(A007) == 2, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 4, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A007,e) == 2, "");
#endif
_Static_assert(sizeof(A008) == 8, "");
_Static_assert(_Alignof(A008) == 4, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A008_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 10, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A008,e) == 33, "");
#endif
_Static_assert(sizeof(A009) == 8, "");
_Static_assert(_Alignof(A009) == 4, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A009_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 10, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A009,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A009,e) == 33, "");
#endif
_Static_assert(sizeof(A010) == 4, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 6, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A010,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A010,e) == 24, "");
#endif
_Static_assert(sizeof(A011) == 2, "");
_Static_assert(_Alignof(A011) == 1, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 4, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A011,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A011,e) == 9, "");
#endif
_Static_assert(sizeof(A012) == 2, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 4, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A012,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A012,e) == 9, "");
#endif
_Static_assert(sizeof(A013) == 8, "");
_Static_assert(_Alignof(A013) == 4, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A013_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 10, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A013,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A013,e) == 40, "");
#endif
_Static_assert(sizeof(A014) == 8, "");
_Static_assert(_Alignof(A014) == 4, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A014_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 10, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A014,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A014,e) == 40, "");
#endif
_Static_assert(sizeof(A015) == 4, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 6, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A015,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A015,e) == 24, "");
#endif
_Static_assert(sizeof(A016) == 2, "");
_Static_assert(_Alignof(A016) == 1, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 4, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A016,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A016,e) == 9, "");
#endif
_Static_assert(sizeof(A017) == 2, "");
_Static_assert(_Alignof(A017) == 2, "");
_Static_assert(sizeof(struct A017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A017_extra_packed) == 1, "");
_Static_assert(sizeof(struct A017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A017_extra_size) == 4, "");
_Static_assert(_Alignof(struct A017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A017,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A017,e) == 9, "");
#endif
_Static_assert(sizeof(A018) == 8, "");
_Static_assert(_Alignof(A018) == 4, "");
_Static_assert(sizeof(struct A018_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A018_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A018_extra_packed) == 1, "");
_Static_assert(sizeof(struct A018_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A018_extra_size) == 10, "");
_Static_assert(_Alignof(struct A018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A018,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A018,e) == 40, "");
#endif
_Static_assert(sizeof(A019) == 8, "");
_Static_assert(_Alignof(A019) == 4, "");
_Static_assert(sizeof(struct A019_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A019_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A019_extra_packed) == 1, "");
_Static_assert(sizeof(struct A019_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A019_extra_size) == 10, "");
_Static_assert(_Alignof(struct A019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A019,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A019,e) == 40, "");
#endif
_Static_assert(sizeof(A100) == 4, "");
_Static_assert(_Alignof(A100) == 4, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 6, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A100,e) == 17, "");
#endif
_Static_assert(sizeof(A101) == 1, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 3, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A101,e) == 3, "");
#endif
_Static_assert(sizeof(A102) == 2, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 4, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A102,e) == 3, "");
#endif
_Static_assert(sizeof(A103) == 8, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 10, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A103,e) == 33, "");
#endif
_Static_assert(sizeof(A104) == 8, "");
_Static_assert(_Alignof(A104) == 4, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A104_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 10, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A104,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A104,e) == 33, "");
#endif
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A105,e) == 17, "");
#endif
_Static_assert(sizeof(A106) == 1, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 3, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A106,e) == 3, "");
#endif
_Static_assert(sizeof(A107) == 2, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 4, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A107,e) == 3, "");
#endif
_Static_assert(sizeof(A108) == 8, "");
_Static_assert(_Alignof(A108) == 4, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A108_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 10, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A108,e) == 33, "");
#endif
_Static_assert(sizeof(A109) == 8, "");
_Static_assert(_Alignof(A109) == 4, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A109_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 10, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A109,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A109,e) == 33, "");
#endif
_Static_assert(sizeof(A110) == 8, "");
_Static_assert(_Alignof(A110) == 4, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A110_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 10, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A110,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A110,e) == 63, "");
#endif
_Static_assert(sizeof(A111) == 5, "");
_Static_assert(_Alignof(A111) == 1, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 7, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A111,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A111,e) == 33, "");
#endif
_Static_assert(sizeof(A112) == 6, "");
_Static_assert(_Alignof(A112) == 2, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A112_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 8, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A112,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A112,e) == 33, "");
#endif
_Static_assert(sizeof(A113) == 8, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 10, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A113,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A113,e) == 63, "");
#endif
_Static_assert(sizeof(A114) == 8, "");
_Static_assert(_Alignof(A114) == 4, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A114_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 10, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A114,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A114,e) == 63, "");
#endif
_Static_assert(sizeof(A115) == 6, "");
_Static_assert(_Alignof(A115) == 2, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A115_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 8, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A115,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A115,e) == 47, "");
#endif
_Static_assert(sizeof(A116) == 5, "");
_Static_assert(_Alignof(A116) == 1, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 7, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A116,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A116,e) == 33, "");
#endif
_Static_assert(sizeof(A117) == 6, "");
_Static_assert(_Alignof(A117) == 2, "");
_Static_assert(sizeof(struct A117_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A117_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A117_extra_packed) == 1, "");
_Static_assert(sizeof(struct A117_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A117_extra_size) == 8, "");
_Static_assert(_Alignof(struct A117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A117,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A117,e) == 33, "");
#endif
_Static_assert(sizeof(A118) == 8, "");
_Static_assert(_Alignof(A118) == 4, "");
_Static_assert(sizeof(struct A118_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A118_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A118_extra_packed) == 1, "");
_Static_assert(sizeof(struct A118_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A118_extra_size) == 10, "");
_Static_assert(_Alignof(struct A118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A118,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A118,e) == 63, "");
#endif
_Static_assert(sizeof(A119) == 8, "");
_Static_assert(_Alignof(A119) == 4, "");
_Static_assert(sizeof(struct A119_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A119_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A119_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A119_extra_packed) == 1, "");
_Static_assert(sizeof(struct A119_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A119_extra_size) == 10, "");
_Static_assert(_Alignof(struct A119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A119,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A119,e) == 63, "");
#endif
_Static_assert(sizeof(A200) == 1, "");
_Static_assert(_Alignof(A200) == 1, "");
_Static_assert(sizeof(struct A200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A200_extra_packed) == 1, "");
_Static_assert(sizeof(struct A200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_size) == 3, "");
_Static_assert(_Alignof(struct A200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A200,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A200,e) == 2, "");
#endif
_Static_assert(sizeof(A201) == 1, "");
_Static_assert(_Alignof(A201) == 1, "");
_Static_assert(sizeof(struct A201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A201_extra_packed) == 1, "");
_Static_assert(sizeof(struct A201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_size) == 3, "");
_Static_assert(_Alignof(struct A201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A201,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A201,e) == 2, "");
#endif
_Static_assert(sizeof(A202) == 1, "");
_Static_assert(_Alignof(A202) == 1, "");
_Static_assert(sizeof(struct A202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A202_extra_packed) == 1, "");
_Static_assert(sizeof(struct A202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_size) == 3, "");
_Static_assert(_Alignof(struct A202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A202,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A202,e) == 2, "");
#endif
_Static_assert(sizeof(A203) == 1, "");
_Static_assert(_Alignof(A203) == 1, "");
_Static_assert(sizeof(struct A203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A203_extra_packed) == 1, "");
_Static_assert(sizeof(struct A203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_size) == 3, "");
_Static_assert(_Alignof(struct A203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A203,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A203,e) == 2, "");
#endif
_Static_assert(sizeof(A204) == 1, "");
_Static_assert(_Alignof(A204) == 1, "");
_Static_assert(sizeof(struct A204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A204_extra_packed) == 1, "");
_Static_assert(sizeof(struct A204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_size) == 3, "");
_Static_assert(_Alignof(struct A204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A204,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A204,e) == 2, "");
#endif
_Static_assert(sizeof(A205) == 1, "");
_Static_assert(_Alignof(A205) == 1, "");
_Static_assert(sizeof(struct A205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A205_extra_packed) == 1, "");
_Static_assert(sizeof(struct A205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_size) == 3, "");
_Static_assert(_Alignof(struct A205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A205,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A205,e) == 2, "");
#endif
_Static_assert(sizeof(A206) == 1, "");
_Static_assert(_Alignof(A206) == 1, "");
_Static_assert(sizeof(struct A206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A206_extra_packed) == 1, "");
_Static_assert(sizeof(struct A206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_size) == 3, "");
_Static_assert(_Alignof(struct A206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A206,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A206,e) == 2, "");
#endif
_Static_assert(sizeof(A207) == 1, "");
_Static_assert(_Alignof(A207) == 1, "");
_Static_assert(sizeof(struct A207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A207_extra_packed) == 1, "");
_Static_assert(sizeof(struct A207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_size) == 3, "");
_Static_assert(_Alignof(struct A207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A207,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A207,e) == 2, "");
#endif
_Static_assert(sizeof(A208) == 1, "");
_Static_assert(_Alignof(A208) == 1, "");
_Static_assert(sizeof(struct A208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A208_extra_packed) == 1, "");
_Static_assert(sizeof(struct A208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_size) == 3, "");
_Static_assert(_Alignof(struct A208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A208,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A208,e) == 2, "");
#endif
_Static_assert(sizeof(A209) == 1, "");
_Static_assert(_Alignof(A209) == 1, "");
_Static_assert(sizeof(struct A209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A209_extra_packed) == 1, "");
_Static_assert(sizeof(struct A209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_size) == 3, "");
_Static_assert(_Alignof(struct A209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A209,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A209,e) == 2, "");
#endif
_Static_assert(sizeof(A210) == 3, "");
_Static_assert(_Alignof(A210) == 1, "");
_Static_assert(sizeof(struct A210_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A210_extra_packed) == 1, "");
_Static_assert(sizeof(struct A210_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_size) == 5, "");
_Static_assert(_Alignof(struct A210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A210,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A210,e) == 16, "");
#endif
_Static_assert(sizeof(A211) == 2, "");
_Static_assert(_Alignof(A211) == 1, "");
_Static_assert(sizeof(struct A211_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A211_extra_packed) == 1, "");
_Static_assert(sizeof(struct A211_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_size) == 4, "");
_Static_assert(_Alignof(struct A211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A211,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A211,e) == 9, "");
#endif
_Static_assert(sizeof(A212) == 2, "");
_Static_assert(_Alignof(A212) == 1, "");
_Static_assert(sizeof(struct A212_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A212_extra_packed) == 1, "");
_Static_assert(sizeof(struct A212_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_size) == 4, "");
_Static_assert(_Alignof(struct A212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A212,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A212,e) == 9, "");
#endif
_Static_assert(sizeof(A213) == 2, "");
_Static_assert(_Alignof(A213) == 1, "");
_Static_assert(sizeof(struct A213_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A213_extra_packed) == 1, "");
_Static_assert(sizeof(struct A213_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_size) == 4, "");
_Static_assert(_Alignof(struct A213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A213,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A213,e) == 9, "");
#endif
_Static_assert(sizeof(A214) == 2, "");
_Static_assert(_Alignof(A214) == 1, "");
_Static_assert(sizeof(struct A214_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A214_extra_packed) == 1, "");
_Static_assert(sizeof(struct A214_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_size) == 4, "");
_Static_assert(_Alignof(struct A214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A214,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A214,e) == 9, "");
#endif
_Static_assert(sizeof(A215) == 2, "");
_Static_assert(_Alignof(A215) == 1, "");
_Static_assert(sizeof(struct A215_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A215_extra_packed) == 1, "");
_Static_assert(sizeof(struct A215_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_size) == 4, "");
_Static_assert(_Alignof(struct A215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A215,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A215,e) == 9, "");
#endif
_Static_assert(sizeof(A216) == 2, "");
_Static_assert(_Alignof(A216) == 1, "");
_Static_assert(sizeof(struct A216_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A216_extra_packed) == 1, "");
_Static_assert(sizeof(struct A216_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_size) == 4, "");
_Static_assert(_Alignof(struct A216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A216,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A216,e) == 9, "");
#endif
_Static_assert(sizeof(A217) == 2, "");
_Static_assert(_Alignof(A217) == 1, "");
_Static_assert(sizeof(struct A217_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A217_extra_packed) == 1, "");
_Static_assert(sizeof(struct A217_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_size) == 4, "");
_Static_assert(_Alignof(struct A217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A217,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A217,e) == 9, "");
#endif
_Static_assert(sizeof(A218) == 2, "");
_Static_assert(_Alignof(A218) == 1, "");
_Static_assert(sizeof(struct A218_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A218_extra_packed) == 1, "");
_Static_assert(sizeof(struct A218_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_size) == 4, "");
_Static_assert(_Alignof(struct A218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A218,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A218,e) == 9, "");
#endif
_Static_assert(sizeof(A219) == 2, "");
_Static_assert(_Alignof(A219) == 1, "");
_Static_assert(sizeof(struct A219_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A219_extra_packed) == 1, "");
_Static_assert(sizeof(struct A219_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_size) == 4, "");
_Static_assert(_Alignof(struct A219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A219,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A219,e) == 9, "");
#endif
_Static_assert(sizeof(A300) == 4, "");
_Static_assert(_Alignof(A300) == 4, "");
_Static_assert(sizeof(struct A300_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A300_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A300_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A300_extra_packed) == 1, "");
_Static_assert(sizeof(struct A300_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A300_extra_size) == 6, "");
_Static_assert(_Alignof(struct A300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A300,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A300,e) == 3, "");
#endif
_Static_assert(sizeof(A301) == 1, "");
_Static_assert(_Alignof(A301) == 1, "");
_Static_assert(sizeof(struct A301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A301_extra_packed) == 1, "");
_Static_assert(sizeof(struct A301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_size) == 3, "");
_Static_assert(_Alignof(struct A301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A301,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A301,e) == 3, "");
#endif
_Static_assert(sizeof(A302) == 2, "");
_Static_assert(_Alignof(A302) == 2, "");
_Static_assert(sizeof(struct A302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A302_extra_packed) == 1, "");
_Static_assert(sizeof(struct A302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A302_extra_size) == 4, "");
_Static_assert(_Alignof(struct A302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A302,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A302,e) == 3, "");
#endif
_Static_assert(sizeof(A303) == 4, "");
_Static_assert(_Alignof(A303) == 4, "");
_Static_assert(sizeof(struct A303_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A303_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A303_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A303_extra_packed) == 1, "");
_Static_assert(sizeof(struct A303_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A303_extra_size) == 6, "");
_Static_assert(_Alignof(struct A303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A303,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A303,e) == 3, "");
#endif
_Static_assert(sizeof(A304) == 4, "");
_Static_assert(_Alignof(A304) == 4, "");
_Static_assert(sizeof(struct A304_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A304_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A304_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A304_extra_packed) == 1, "");
_Static_assert(sizeof(struct A304_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A304_extra_size) == 6, "");
_Static_assert(_Alignof(struct A304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A304,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A304,e) == 3, "");
#endif
_Static_assert(sizeof(A305) == 1, "");
_Static_assert(_Alignof(A305) == 1, "");
_Static_assert(sizeof(struct A305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A305_extra_packed) == 1, "");
_Static_assert(sizeof(struct A305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_size) == 3, "");
_Static_assert(_Alignof(struct A305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A305,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A305,e) == 3, "");
#endif
_Static_assert(sizeof(A306) == 1, "");
_Static_assert(_Alignof(A306) == 1, "");
_Static_assert(sizeof(struct A306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A306_extra_packed) == 1, "");
_Static_assert(sizeof(struct A306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_size) == 3, "");
_Static_assert(_Alignof(struct A306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A306,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A306,e) == 3, "");
#endif
_Static_assert(sizeof(A307) == 2, "");
_Static_assert(_Alignof(A307) == 2, "");
_Static_assert(sizeof(struct A307_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A307_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A307_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A307_extra_packed) == 1, "");
_Static_assert(sizeof(struct A307_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_size) == 4, "");
_Static_assert(_Alignof(struct A307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A307,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A307,e) == 3, "");
#endif
_Static_assert(sizeof(A308) == 4, "");
_Static_assert(_Alignof(A308) == 4, "");
_Static_assert(sizeof(struct A308_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A308_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A308_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A308_extra_packed) == 1, "");
_Static_assert(sizeof(struct A308_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_size) == 6, "");
_Static_assert(_Alignof(struct A308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A308,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A308,e) == 3, "");
#endif
_Static_assert(sizeof(A309) == 4, "");
_Static_assert(_Alignof(A309) == 4, "");
_Static_assert(sizeof(struct A309_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A309_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A309_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A309_extra_packed) == 1, "");
_Static_assert(sizeof(struct A309_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_size) == 6, "");
_Static_assert(_Alignof(struct A309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A309,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A309,e) == 3, "");
#endif
_Static_assert(sizeof(A310) == 8, "");
_Static_assert(_Alignof(A310) == 4, "");
_Static_assert(sizeof(struct A310_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A310_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A310_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A310_extra_packed) == 1, "");
_Static_assert(sizeof(struct A310_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A310_extra_size) == 10, "");
_Static_assert(_Alignof(struct A310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A310,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A310,e) == 63, "");
#endif
_Static_assert(sizeof(A311) == 5, "");
_Static_assert(_Alignof(A311) == 1, "");
_Static_assert(sizeof(struct A311_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A311_extra_packed) == 1, "");
_Static_assert(sizeof(struct A311_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_size) == 7, "");
_Static_assert(_Alignof(struct A311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A311,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A311,e) == 33, "");
#endif
_Static_assert(sizeof(A312) == 6, "");
_Static_assert(_Alignof(A312) == 2, "");
_Static_assert(sizeof(struct A312_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A312_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A312_extra_packed) == 1, "");
_Static_assert(sizeof(struct A312_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A312_extra_size) == 8, "");
_Static_assert(_Alignof(struct A312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A312,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A312,e) == 33, "");
#endif
_Static_assert(sizeof(A313) == 8, "");
_Static_assert(_Alignof(A313) == 4, "");
_Static_assert(sizeof(struct A313_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A313_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A313_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A313_extra_packed) == 1, "");
_Static_assert(sizeof(struct A313_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A313_extra_size) == 10, "");
_Static_assert(_Alignof(struct A313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A313,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A313,e) == 33, "");
#endif
_Static_assert(sizeof(A314) == 8, "");
_Static_assert(_Alignof(A314) == 4, "");
_Static_assert(sizeof(struct A314_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A314_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A314_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A314_extra_packed) == 1, "");
_Static_assert(sizeof(struct A314_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A314_extra_size) == 10, "");
_Static_assert(_Alignof(struct A314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A314,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A314,e) == 33, "");
#endif
_Static_assert(sizeof(A315) == 5, "");
_Static_assert(_Alignof(A315) == 1, "");
_Static_assert(sizeof(struct A315_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A315_extra_packed) == 1, "");
_Static_assert(sizeof(struct A315_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_size) == 7, "");
_Static_assert(_Alignof(struct A315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A315,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A315,e) == 33, "");
#endif
_Static_assert(sizeof(A316) == 5, "");
_Static_assert(_Alignof(A316) == 1, "");
_Static_assert(sizeof(struct A316_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A316_extra_packed) == 1, "");
_Static_assert(sizeof(struct A316_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_size) == 7, "");
_Static_assert(_Alignof(struct A316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A316,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A316,e) == 33, "");
#endif
_Static_assert(sizeof(A317) == 6, "");
_Static_assert(_Alignof(A317) == 2, "");
_Static_assert(sizeof(struct A317_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A317_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A317_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A317_extra_packed) == 1, "");
_Static_assert(sizeof(struct A317_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_size) == 8, "");
_Static_assert(_Alignof(struct A317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A317,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A317,e) == 33, "");
#endif
_Static_assert(sizeof(A318) == 8, "");
_Static_assert(_Alignof(A318) == 4, "");
_Static_assert(sizeof(struct A318_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A318_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A318_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A318_extra_packed) == 1, "");
_Static_assert(sizeof(struct A318_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_size) == 10, "");
_Static_assert(_Alignof(struct A318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A318,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A318,e) == 33, "");
#endif
_Static_assert(sizeof(A319) == 8, "");
_Static_assert(_Alignof(A319) == 4, "");
_Static_assert(sizeof(struct A319_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A319_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A319_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A319_extra_packed) == 1, "");
_Static_assert(sizeof(struct A319_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_size) == 10, "");
_Static_assert(_Alignof(struct A319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A319,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A319,e) == 33, "");
#endif
_Static_assert(sizeof(A410) == 8, "");
_Static_assert(_Alignof(A410) == 4, "");
_Static_assert(sizeof(struct A410_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A410_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A410_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A410_extra_packed) == 1, "");
_Static_assert(sizeof(struct A410_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A410_extra_size) == 10, "");
_Static_assert(_Alignof(struct A410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A410,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A410,e) == 46, "");
#endif
_Static_assert(sizeof(A411) == 5, "");
_Static_assert(_Alignof(A411) == 1, "");
_Static_assert(sizeof(struct A411_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A411_extra_packed) == 1, "");
_Static_assert(sizeof(struct A411_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_size) == 7, "");
_Static_assert(_Alignof(struct A411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A411,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A411,e) == 32, "");
#endif
_Static_assert(sizeof(A412) == 6, "");
_Static_assert(_Alignof(A412) == 2, "");
_Static_assert(sizeof(struct A412_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A412_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A412_extra_packed) == 1, "");
_Static_assert(sizeof(struct A412_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A412_extra_size) == 8, "");
_Static_assert(_Alignof(struct A412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A412,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A412,e) == 32, "");
#endif
_Static_assert(sizeof(A413) == 8, "");
_Static_assert(_Alignof(A413) == 4, "");
_Static_assert(sizeof(struct A413_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A413_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A413_extra_packed) == 1, "");
_Static_assert(sizeof(struct A413_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A413_extra_size) == 10, "");
_Static_assert(_Alignof(struct A413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A413,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A413,e) == 62, "");
#endif
_Static_assert(sizeof(A414) == 8, "");
_Static_assert(_Alignof(A414) == 4, "");
_Static_assert(sizeof(struct A414_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A414_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A414_extra_packed) == 1, "");
_Static_assert(sizeof(struct A414_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A414_extra_size) == 10, "");
_Static_assert(_Alignof(struct A414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A414,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A414,e) == 62, "");
#endif
_Static_assert(sizeof(A415) == 6, "");
_Static_assert(_Alignof(A415) == 2, "");
_Static_assert(sizeof(struct A415_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A415_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A415_extra_packed) == 1, "");
_Static_assert(sizeof(struct A415_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A415_extra_size) == 8, "");
_Static_assert(_Alignof(struct A415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A415,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A415,e) == 46, "");
#endif
_Static_assert(sizeof(A416) == 5, "");
_Static_assert(_Alignof(A416) == 1, "");
_Static_assert(sizeof(struct A416_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A416_extra_packed) == 1, "");
_Static_assert(sizeof(struct A416_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_size) == 7, "");
_Static_assert(_Alignof(struct A416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A416,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A416,e) == 32, "");
#endif
_Static_assert(sizeof(A417) == 6, "");
_Static_assert(_Alignof(A417) == 2, "");
_Static_assert(sizeof(struct A417_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A417_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A417_extra_packed) == 1, "");
_Static_assert(sizeof(struct A417_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A417_extra_size) == 8, "");
_Static_assert(_Alignof(struct A417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A417,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A417,e) == 32, "");
#endif
_Static_assert(sizeof(A418) == 8, "");
_Static_assert(_Alignof(A418) == 4, "");
_Static_assert(sizeof(struct A418_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A418_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A418_extra_packed) == 1, "");
_Static_assert(sizeof(struct A418_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A418_extra_size) == 10, "");
_Static_assert(_Alignof(struct A418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A418,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A418,e) == 62, "");
#endif
_Static_assert(sizeof(A419) == 8, "");
_Static_assert(_Alignof(A419) == 4, "");
_Static_assert(sizeof(struct A419_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A419_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A419_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A419_extra_packed) == 1, "");
_Static_assert(sizeof(struct A419_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A419_extra_size) == 10, "");
_Static_assert(_Alignof(struct A419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A419,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A419,e) == 62, "");
#endif
_Static_assert(sizeof(A510) == 8, "");
_Static_assert(_Alignof(A510) == 4, "");
_Static_assert(sizeof(struct A510_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A510_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A510_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A510_extra_packed) == 1, "");
_Static_assert(sizeof(struct A510_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A510_extra_size) == 10, "");
_Static_assert(_Alignof(struct A510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A510,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A510,e) == 32, "");
#endif
_Static_assert(sizeof(A511) == 5, "");
_Static_assert(_Alignof(A511) == 1, "");
_Static_assert(sizeof(struct A511_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A511_extra_packed) == 1, "");
_Static_assert(sizeof(struct A511_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_size) == 7, "");
_Static_assert(_Alignof(struct A511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A511,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A511,e) == 32, "");
#endif
_Static_assert(sizeof(A512) == 6, "");
_Static_assert(_Alignof(A512) == 2, "");
_Static_assert(sizeof(struct A512_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A512_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A512_extra_packed) == 1, "");
_Static_assert(sizeof(struct A512_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A512_extra_size) == 8, "");
_Static_assert(_Alignof(struct A512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A512,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A512,e) == 32, "");
#endif
_Static_assert(sizeof(A513) == 8, "");
_Static_assert(_Alignof(A513) == 4, "");
_Static_assert(sizeof(struct A513_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A513_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A513_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A513_extra_packed) == 1, "");
_Static_assert(sizeof(struct A513_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A513_extra_size) == 10, "");
_Static_assert(_Alignof(struct A513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A513,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A513,e) == 32, "");
#endif
_Static_assert(sizeof(A514) == 8, "");
_Static_assert(_Alignof(A514) == 4, "");
_Static_assert(sizeof(struct A514_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A514_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A514_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A514_extra_packed) == 1, "");
_Static_assert(sizeof(struct A514_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A514_extra_size) == 10, "");
_Static_assert(_Alignof(struct A514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A514,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A514,e) == 32, "");
#endif
_Static_assert(sizeof(A515) == 5, "");
_Static_assert(_Alignof(A515) == 1, "");
_Static_assert(sizeof(struct A515_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A515_extra_packed) == 1, "");
_Static_assert(sizeof(struct A515_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_size) == 7, "");
_Static_assert(_Alignof(struct A515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A515,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A515,e) == 32, "");
#endif
_Static_assert(sizeof(A516) == 5, "");
_Static_assert(_Alignof(A516) == 1, "");
_Static_assert(sizeof(struct A516_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A516_extra_packed) == 1, "");
_Static_assert(sizeof(struct A516_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_size) == 7, "");
_Static_assert(_Alignof(struct A516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A516,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A516,e) == 32, "");
#endif
_Static_assert(sizeof(A517) == 6, "");
_Static_assert(_Alignof(A517) == 2, "");
_Static_assert(sizeof(struct A517_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A517_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A517_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A517_extra_packed) == 1, "");
_Static_assert(sizeof(struct A517_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_size) == 8, "");
_Static_assert(_Alignof(struct A517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A517,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A517,e) == 32, "");
#endif
_Static_assert(sizeof(A518) == 8, "");
_Static_assert(_Alignof(A518) == 4, "");
_Static_assert(sizeof(struct A518_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A518_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A518_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A518_extra_packed) == 1, "");
_Static_assert(sizeof(struct A518_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_size) == 10, "");
_Static_assert(_Alignof(struct A518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A518,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A518,e) == 32, "");
#endif
_Static_assert(sizeof(A519) == 8, "");
_Static_assert(_Alignof(A519) == 4, "");
_Static_assert(sizeof(struct A519_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A519_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A519_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A519_extra_packed) == 1, "");
_Static_assert(sizeof(struct A519_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_size) == 10, "");
_Static_assert(_Alignof(struct A519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A519,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A519,e) == 32, "");
#endif
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 2, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B000,e) == 0, "");
#endif
_Static_assert(sizeof(B001) == 1, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 3, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B001,e) == 0, "");
#endif
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 2, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B002,e) == 0, "");
#endif
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 4, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B003,e) == 0, "");
#endif
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 4, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B004,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B004,e) == 0, "");
#endif
_Static_assert(sizeof(B005) == 2, "");
_Static_assert(_Alignof(B005) == 2, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B005_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 4, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B005,e) == 0, "");
#endif
_Static_assert(sizeof(B006) == 1, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 3, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B006,e) == 0, "");
#endif
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 2, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B007,e) == 0, "");
#endif
_Static_assert(sizeof(B008) == 4, "");
_Static_assert(_Alignof(B008) == 4, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B008_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 6, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B008,e) == 0, "");
#endif
_Static_assert(sizeof(B009) == 4, "");
_Static_assert(_Alignof(B009) == 4, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B009_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 6, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B009,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B009,e) == 0, "");
#endif
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 2, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B010,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B010,e) == 0, "");
#endif
_Static_assert(sizeof(B011) == 1, "");
_Static_assert(_Alignof(B011) == 1, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 3, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B011,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B011,e) == 0, "");
#endif
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 2, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B012,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B012,e) == 0, "");
#endif
_Static_assert(sizeof(B013) == 4, "");
_Static_assert(_Alignof(B013) == 4, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B013_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 6, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B013,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B013,e) == 0, "");
#endif
_Static_assert(sizeof(B014) == 4, "");
_Static_assert(_Alignof(B014) == 4, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B014_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 6, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B014,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B014,e) == 0, "");
#endif
_Static_assert(sizeof(B015) == 2, "");
_Static_assert(_Alignof(B015) == 2, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 4, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B015,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B015,e) == 0, "");
#endif
_Static_assert(sizeof(B016) == 1, "");
_Static_assert(_Alignof(B016) == 1, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 3, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B016,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B016,e) == 0, "");
#endif
_Static_assert(sizeof(B017) == 2, "");
_Static_assert(_Alignof(B017) == 2, "");
_Static_assert(sizeof(struct B017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B017_extra_packed) == 1, "");
_Static_assert(sizeof(struct B017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B017_extra_size) == 4, "");
_Static_assert(_Alignof(struct B017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B017,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B017,e) == 0, "");
#endif
_Static_assert(sizeof(B018) == 4, "");
_Static_assert(_Alignof(B018) == 4, "");
_Static_assert(sizeof(struct B018_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B018_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B018_extra_packed) == 1, "");
_Static_assert(sizeof(struct B018_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B018_extra_size) == 6, "");
_Static_assert(_Alignof(struct B018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B018,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B018,e) == 0, "");
#endif
_Static_assert(sizeof(B019) == 4, "");
_Static_assert(_Alignof(B019) == 4, "");
_Static_assert(sizeof(struct B019_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B019_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B019_extra_packed) == 1, "");
_Static_assert(sizeof(struct B019_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B019_extra_size) == 6, "");
_Static_assert(_Alignof(struct B019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B019,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B019,e) == 0, "");
#endif
_Static_assert(sizeof(B100) == 4, "");
_Static_assert(_Alignof(B100) == 4, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 6, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B100,e) == 0, "");
#endif
_Static_assert(sizeof(B101) == 1, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 3, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B101,e) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B102,e) == 0, "");
#endif
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B103,e) == 0, "");
#endif
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 4, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B104,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B104,e) == 0, "");
#endif
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B105,e) == 0, "");
#endif
_Static_assert(sizeof(B106) == 1, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 3, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B106,e) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B107,e) == 0, "");
#endif
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 4, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B108,e) == 0, "");
#endif
_Static_assert(sizeof(B109) == 4, "");
_Static_assert(_Alignof(B109) == 4, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 6, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B109,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B109,e) == 0, "");
#endif
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 4, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B110,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B110,e) == 0, "");
#endif
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 1, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B111,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B111,e) == 0, "");
#endif
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 2, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B112,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B112,e) == 0, "");
#endif
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B113,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B113,e) == 0, "");
#endif
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 4, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B114,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B114,e) == 0, "");
#endif
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 2, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B115,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B115,e) == 0, "");
#endif
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 1, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B116,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B116,e) == 0, "");
#endif
_Static_assert(sizeof(B117) == 4, "");
_Static_assert(_Alignof(B117) == 2, "");
_Static_assert(sizeof(struct B117_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B117_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B117_extra_packed) == 1, "");
_Static_assert(sizeof(struct B117_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B117_extra_size) == 6, "");
_Static_assert(_Alignof(struct B117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B117,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B117,e) == 0, "");
#endif
_Static_assert(sizeof(B118) == 4, "");
_Static_assert(_Alignof(B118) == 4, "");
_Static_assert(sizeof(struct B118_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B118_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B118_extra_packed) == 1, "");
_Static_assert(sizeof(struct B118_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B118_extra_size) == 6, "");
_Static_assert(_Alignof(struct B118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B118,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B118,e) == 0, "");
#endif
_Static_assert(sizeof(B119) == 4, "");
_Static_assert(_Alignof(B119) == 4, "");
_Static_assert(sizeof(struct B119_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B119_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B119_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B119_extra_packed) == 1, "");
_Static_assert(sizeof(struct B119_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B119_extra_size) == 6, "");
_Static_assert(_Alignof(struct B119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B119,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B119,e) == 0, "");
#endif
_Static_assert(sizeof(B200) == 1, "");
_Static_assert(_Alignof(B200) == 1, "");
_Static_assert(sizeof(struct B200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B200_extra_packed) == 1, "");
_Static_assert(sizeof(struct B200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_size) == 3, "");
_Static_assert(_Alignof(struct B200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B200,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B200,e) == 0, "");
#endif
_Static_assert(sizeof(B201) == 1, "");
_Static_assert(_Alignof(B201) == 1, "");
_Static_assert(sizeof(struct B201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B201_extra_packed) == 1, "");
_Static_assert(sizeof(struct B201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_size) == 3, "");
_Static_assert(_Alignof(struct B201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B201,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B201,e) == 0, "");
#endif
_Static_assert(sizeof(B202) == 1, "");
_Static_assert(_Alignof(B202) == 1, "");
_Static_assert(sizeof(struct B202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B202_extra_packed) == 1, "");
_Static_assert(sizeof(struct B202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_size) == 3, "");
_Static_assert(_Alignof(struct B202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B202,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B202,e) == 0, "");
#endif
_Static_assert(sizeof(B203) == 1, "");
_Static_assert(_Alignof(B203) == 1, "");
_Static_assert(sizeof(struct B203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B203_extra_packed) == 1, "");
_Static_assert(sizeof(struct B203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_size) == 3, "");
_Static_assert(_Alignof(struct B203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B203,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B203,e) == 0, "");
#endif
_Static_assert(sizeof(B204) == 1, "");
_Static_assert(_Alignof(B204) == 1, "");
_Static_assert(sizeof(struct B204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B204_extra_packed) == 1, "");
_Static_assert(sizeof(struct B204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_size) == 3, "");
_Static_assert(_Alignof(struct B204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B204,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B204,e) == 0, "");
#endif
_Static_assert(sizeof(B205) == 1, "");
_Static_assert(_Alignof(B205) == 1, "");
_Static_assert(sizeof(struct B205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B205_extra_packed) == 1, "");
_Static_assert(sizeof(struct B205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_size) == 3, "");
_Static_assert(_Alignof(struct B205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B205,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B205,e) == 0, "");
#endif
_Static_assert(sizeof(B206) == 1, "");
_Static_assert(_Alignof(B206) == 1, "");
_Static_assert(sizeof(struct B206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B206_extra_packed) == 1, "");
_Static_assert(sizeof(struct B206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_size) == 3, "");
_Static_assert(_Alignof(struct B206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B206,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B206,e) == 0, "");
#endif
_Static_assert(sizeof(B207) == 1, "");
_Static_assert(_Alignof(B207) == 1, "");
_Static_assert(sizeof(struct B207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B207_extra_packed) == 1, "");
_Static_assert(sizeof(struct B207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_size) == 3, "");
_Static_assert(_Alignof(struct B207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B207,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B207,e) == 0, "");
#endif
_Static_assert(sizeof(B208) == 1, "");
_Static_assert(_Alignof(B208) == 1, "");
_Static_assert(sizeof(struct B208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B208_extra_packed) == 1, "");
_Static_assert(sizeof(struct B208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_size) == 3, "");
_Static_assert(_Alignof(struct B208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B208,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B208,e) == 0, "");
#endif
_Static_assert(sizeof(B209) == 1, "");
_Static_assert(_Alignof(B209) == 1, "");
_Static_assert(sizeof(struct B209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B209_extra_packed) == 1, "");
_Static_assert(sizeof(struct B209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_size) == 3, "");
_Static_assert(_Alignof(struct B209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B209,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B209,e) == 0, "");
#endif
_Static_assert(sizeof(B210) == 1, "");
_Static_assert(_Alignof(B210) == 1, "");
_Static_assert(sizeof(struct B210_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B210_extra_packed) == 1, "");
_Static_assert(sizeof(struct B210_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_size) == 3, "");
_Static_assert(_Alignof(struct B210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B210,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B210,e) == 0, "");
#endif
_Static_assert(sizeof(B211) == 1, "");
_Static_assert(_Alignof(B211) == 1, "");
_Static_assert(sizeof(struct B211_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B211_extra_packed) == 1, "");
_Static_assert(sizeof(struct B211_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_size) == 3, "");
_Static_assert(_Alignof(struct B211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B211,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B211,e) == 0, "");
#endif
_Static_assert(sizeof(B212) == 1, "");
_Static_assert(_Alignof(B212) == 1, "");
_Static_assert(sizeof(struct B212_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B212_extra_packed) == 1, "");
_Static_assert(sizeof(struct B212_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_size) == 3, "");
_Static_assert(_Alignof(struct B212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B212,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B212,e) == 0, "");
#endif
_Static_assert(sizeof(B213) == 1, "");
_Static_assert(_Alignof(B213) == 1, "");
_Static_assert(sizeof(struct B213_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B213_extra_packed) == 1, "");
_Static_assert(sizeof(struct B213_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_size) == 3, "");
_Static_assert(_Alignof(struct B213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B213,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B213,e) == 0, "");
#endif
_Static_assert(sizeof(B214) == 1, "");
_Static_assert(_Alignof(B214) == 1, "");
_Static_assert(sizeof(struct B214_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B214_extra_packed) == 1, "");
_Static_assert(sizeof(struct B214_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_size) == 3, "");
_Static_assert(_Alignof(struct B214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B214,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B214,e) == 0, "");
#endif
_Static_assert(sizeof(B215) == 1, "");
_Static_assert(_Alignof(B215) == 1, "");
_Static_assert(sizeof(struct B215_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B215_extra_packed) == 1, "");
_Static_assert(sizeof(struct B215_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_size) == 3, "");
_Static_assert(_Alignof(struct B215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B215,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B215,e) == 0, "");
#endif
_Static_assert(sizeof(B216) == 1, "");
_Static_assert(_Alignof(B216) == 1, "");
_Static_assert(sizeof(struct B216_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B216_extra_packed) == 1, "");
_Static_assert(sizeof(struct B216_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_size) == 3, "");
_Static_assert(_Alignof(struct B216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B216,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B216,e) == 0, "");
#endif
_Static_assert(sizeof(B217) == 1, "");
_Static_assert(_Alignof(B217) == 1, "");
_Static_assert(sizeof(struct B217_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B217_extra_packed) == 1, "");
_Static_assert(sizeof(struct B217_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_size) == 3, "");
_Static_assert(_Alignof(struct B217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B217,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B217,e) == 0, "");
#endif
_Static_assert(sizeof(B218) == 1, "");
_Static_assert(_Alignof(B218) == 1, "");
_Static_assert(sizeof(struct B218_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B218_extra_packed) == 1, "");
_Static_assert(sizeof(struct B218_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_size) == 3, "");
_Static_assert(_Alignof(struct B218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B218,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B218,e) == 0, "");
#endif
_Static_assert(sizeof(B219) == 1, "");
_Static_assert(_Alignof(B219) == 1, "");
_Static_assert(sizeof(struct B219_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B219_extra_packed) == 1, "");
_Static_assert(sizeof(struct B219_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_size) == 3, "");
_Static_assert(_Alignof(struct B219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B219,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B219,e) == 0, "");
#endif
_Static_assert(sizeof(B300) == 4, "");
_Static_assert(_Alignof(B300) == 4, "");
_Static_assert(sizeof(struct B300_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B300_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B300_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B300_extra_packed) == 1, "");
_Static_assert(sizeof(struct B300_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B300_extra_size) == 6, "");
_Static_assert(_Alignof(struct B300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B300,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B300,e) == 0, "");
#endif
_Static_assert(sizeof(B301) == 1, "");
_Static_assert(_Alignof(B301) == 1, "");
_Static_assert(sizeof(struct B301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B301_extra_packed) == 1, "");
_Static_assert(sizeof(struct B301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_size) == 3, "");
_Static_assert(_Alignof(struct B301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B301,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B301,e) == 0, "");
#endif
_Static_assert(sizeof(B302) == 2, "");
_Static_assert(_Alignof(B302) == 2, "");
_Static_assert(sizeof(struct B302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B302_extra_packed) == 1, "");
_Static_assert(sizeof(struct B302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B302_extra_size) == 4, "");
_Static_assert(_Alignof(struct B302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B302,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B302,e) == 0, "");
#endif
_Static_assert(sizeof(B303) == 4, "");
_Static_assert(_Alignof(B303) == 4, "");
_Static_assert(sizeof(struct B303_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B303_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B303_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B303_extra_packed) == 1, "");
_Static_assert(sizeof(struct B303_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B303_extra_size) == 6, "");
_Static_assert(_Alignof(struct B303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B303,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B303,e) == 0, "");
#endif
_Static_assert(sizeof(B304) == 4, "");
_Static_assert(_Alignof(B304) == 4, "");
_Static_assert(sizeof(struct B304_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B304_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B304_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B304_extra_packed) == 1, "");
_Static_assert(sizeof(struct B304_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B304_extra_size) == 6, "");
_Static_assert(_Alignof(struct B304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B304,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B304,e) == 0, "");
#endif
_Static_assert(sizeof(B305) == 1, "");
_Static_assert(_Alignof(B305) == 1, "");
_Static_assert(sizeof(struct B305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B305_extra_packed) == 1, "");
_Static_assert(sizeof(struct B305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_size) == 3, "");
_Static_assert(_Alignof(struct B305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B305,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B305,e) == 0, "");
#endif
_Static_assert(sizeof(B306) == 1, "");
_Static_assert(_Alignof(B306) == 1, "");
_Static_assert(sizeof(struct B306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B306_extra_packed) == 1, "");
_Static_assert(sizeof(struct B306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_size) == 3, "");
_Static_assert(_Alignof(struct B306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B306,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B306,e) == 0, "");
#endif
_Static_assert(sizeof(B307) == 2, "");
_Static_assert(_Alignof(B307) == 2, "");
_Static_assert(sizeof(struct B307_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B307_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B307_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B307_extra_packed) == 1, "");
_Static_assert(sizeof(struct B307_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_size) == 4, "");
_Static_assert(_Alignof(struct B307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B307,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B307,e) == 0, "");
#endif
_Static_assert(sizeof(B308) == 4, "");
_Static_assert(_Alignof(B308) == 4, "");
_Static_assert(sizeof(struct B308_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B308_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B308_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B308_extra_packed) == 1, "");
_Static_assert(sizeof(struct B308_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_size) == 6, "");
_Static_assert(_Alignof(struct B308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B308,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B308,e) == 0, "");
#endif
_Static_assert(sizeof(B309) == 4, "");
_Static_assert(_Alignof(B309) == 4, "");
_Static_assert(sizeof(struct B309_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B309_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B309_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B309_extra_packed) == 1, "");
_Static_assert(sizeof(struct B309_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_size) == 6, "");
_Static_assert(_Alignof(struct B309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B309,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B309,e) == 0, "");
#endif
_Static_assert(sizeof(B310) == 4, "");
_Static_assert(_Alignof(B310) == 4, "");
_Static_assert(sizeof(struct B310_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B310_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B310_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B310_extra_packed) == 1, "");
_Static_assert(sizeof(struct B310_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B310_extra_size) == 6, "");
_Static_assert(_Alignof(struct B310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B310,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B310,e) == 0, "");
#endif
_Static_assert(sizeof(B311) == 4, "");
_Static_assert(_Alignof(B311) == 1, "");
_Static_assert(sizeof(struct B311_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B311_extra_packed) == 1, "");
_Static_assert(sizeof(struct B311_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_size) == 6, "");
_Static_assert(_Alignof(struct B311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B311,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B311,e) == 0, "");
#endif
_Static_assert(sizeof(B312) == 4, "");
_Static_assert(_Alignof(B312) == 2, "");
_Static_assert(sizeof(struct B312_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B312_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B312_extra_packed) == 1, "");
_Static_assert(sizeof(struct B312_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B312_extra_size) == 6, "");
_Static_assert(_Alignof(struct B312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B312,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B312,e) == 0, "");
#endif
_Static_assert(sizeof(B313) == 4, "");
_Static_assert(_Alignof(B313) == 4, "");
_Static_assert(sizeof(struct B313_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B313_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B313_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B313_extra_packed) == 1, "");
_Static_assert(sizeof(struct B313_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B313_extra_size) == 6, "");
_Static_assert(_Alignof(struct B313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B313,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B313,e) == 0, "");
#endif
_Static_assert(sizeof(B314) == 4, "");
_Static_assert(_Alignof(B314) == 4, "");
_Static_assert(sizeof(struct B314_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B314_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B314_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B314_extra_packed) == 1, "");
_Static_assert(sizeof(struct B314_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B314_extra_size) == 6, "");
_Static_assert(_Alignof(struct B314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B314,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B314,e) == 0, "");
#endif
_Static_assert(sizeof(B315) == 4, "");
_Static_assert(_Alignof(B315) == 1, "");
_Static_assert(sizeof(struct B315_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B315_extra_packed) == 1, "");
_Static_assert(sizeof(struct B315_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_size) == 6, "");
_Static_assert(_Alignof(struct B315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B315,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B315,e) == 0, "");
#endif
_Static_assert(sizeof(B316) == 4, "");
_Static_assert(_Alignof(B316) == 1, "");
_Static_assert(sizeof(struct B316_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B316_extra_packed) == 1, "");
_Static_assert(sizeof(struct B316_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_size) == 6, "");
_Static_assert(_Alignof(struct B316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B316,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B316,e) == 0, "");
#endif
_Static_assert(sizeof(B317) == 4, "");
_Static_assert(_Alignof(B317) == 2, "");
_Static_assert(sizeof(struct B317_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B317_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B317_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B317_extra_packed) == 1, "");
_Static_assert(sizeof(struct B317_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_size) == 6, "");
_Static_assert(_Alignof(struct B317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B317,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B317,e) == 0, "");
#endif
_Static_assert(sizeof(B318) == 4, "");
_Static_assert(_Alignof(B318) == 4, "");
_Static_assert(sizeof(struct B318_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B318_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B318_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B318_extra_packed) == 1, "");
_Static_assert(sizeof(struct B318_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_size) == 6, "");
_Static_assert(_Alignof(struct B318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B318,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B318,e) == 0, "");
#endif
_Static_assert(sizeof(B319) == 4, "");
_Static_assert(_Alignof(B319) == 4, "");
_Static_assert(sizeof(struct B319_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B319_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B319_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B319_extra_packed) == 1, "");
_Static_assert(sizeof(struct B319_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_size) == 6, "");
_Static_assert(_Alignof(struct B319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B319,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B319,e) == 0, "");
#endif
_Static_assert(sizeof(B410) == 4, "");
_Static_assert(_Alignof(B410) == 4, "");
_Static_assert(sizeof(struct B410_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B410_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B410_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B410_extra_packed) == 1, "");
_Static_assert(sizeof(struct B410_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B410_extra_size) == 6, "");
_Static_assert(_Alignof(struct B410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B410,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B410,e) == 0, "");
#endif
_Static_assert(sizeof(B411) == 4, "");
_Static_assert(_Alignof(B411) == 1, "");
_Static_assert(sizeof(struct B411_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B411_extra_packed) == 1, "");
_Static_assert(sizeof(struct B411_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_size) == 6, "");
_Static_assert(_Alignof(struct B411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B411,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B411,e) == 0, "");
#endif
_Static_assert(sizeof(B412) == 4, "");
_Static_assert(_Alignof(B412) == 2, "");
_Static_assert(sizeof(struct B412_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B412_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B412_extra_packed) == 1, "");
_Static_assert(sizeof(struct B412_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B412_extra_size) == 6, "");
_Static_assert(_Alignof(struct B412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B412,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B412,e) == 0, "");
#endif
_Static_assert(sizeof(B413) == 4, "");
_Static_assert(_Alignof(B413) == 4, "");
_Static_assert(sizeof(struct B413_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B413_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B413_extra_packed) == 1, "");
_Static_assert(sizeof(struct B413_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B413_extra_size) == 6, "");
_Static_assert(_Alignof(struct B413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B413,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B413,e) == 0, "");
#endif
_Static_assert(sizeof(B414) == 4, "");
_Static_assert(_Alignof(B414) == 4, "");
_Static_assert(sizeof(struct B414_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B414_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B414_extra_packed) == 1, "");
_Static_assert(sizeof(struct B414_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B414_extra_size) == 6, "");
_Static_assert(_Alignof(struct B414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B414,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B414,e) == 0, "");
#endif
_Static_assert(sizeof(B415) == 4, "");
_Static_assert(_Alignof(B415) == 2, "");
_Static_assert(sizeof(struct B415_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B415_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B415_extra_packed) == 1, "");
_Static_assert(sizeof(struct B415_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B415_extra_size) == 6, "");
_Static_assert(_Alignof(struct B415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B415,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B415,e) == 0, "");
#endif
_Static_assert(sizeof(B416) == 4, "");
_Static_assert(_Alignof(B416) == 1, "");
_Static_assert(sizeof(struct B416_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B416_extra_packed) == 1, "");
_Static_assert(sizeof(struct B416_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_size) == 6, "");
_Static_assert(_Alignof(struct B416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B416,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B416,e) == 0, "");
#endif
_Static_assert(sizeof(B417) == 4, "");
_Static_assert(_Alignof(B417) == 2, "");
_Static_assert(sizeof(struct B417_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B417_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B417_extra_packed) == 1, "");
_Static_assert(sizeof(struct B417_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B417_extra_size) == 6, "");
_Static_assert(_Alignof(struct B417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B417,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B417,e) == 0, "");
#endif
_Static_assert(sizeof(B418) == 4, "");
_Static_assert(_Alignof(B418) == 4, "");
_Static_assert(sizeof(struct B418_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B418_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B418_extra_packed) == 1, "");
_Static_assert(sizeof(struct B418_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B418_extra_size) == 6, "");
_Static_assert(_Alignof(struct B418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B418,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B418,e) == 0, "");
#endif
_Static_assert(sizeof(B419) == 4, "");
_Static_assert(_Alignof(B419) == 4, "");
_Static_assert(sizeof(struct B419_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B419_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B419_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B419_extra_packed) == 1, "");
_Static_assert(sizeof(struct B419_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B419_extra_size) == 6, "");
_Static_assert(_Alignof(struct B419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B419,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B419,e) == 0, "");
#endif
_Static_assert(sizeof(B510) == 4, "");
_Static_assert(_Alignof(B510) == 4, "");
_Static_assert(sizeof(struct B510_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B510_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B510_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B510_extra_packed) == 1, "");
_Static_assert(sizeof(struct B510_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B510_extra_size) == 6, "");
_Static_assert(_Alignof(struct B510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B510,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B510,e) == 0, "");
#endif
_Static_assert(sizeof(B511) == 4, "");
_Static_assert(_Alignof(B511) == 1, "");
_Static_assert(sizeof(struct B511_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B511_extra_packed) == 1, "");
_Static_assert(sizeof(struct B511_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_size) == 6, "");
_Static_assert(_Alignof(struct B511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B511,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B511,e) == 0, "");
#endif
_Static_assert(sizeof(B512) == 4, "");
_Static_assert(_Alignof(B512) == 2, "");
_Static_assert(sizeof(struct B512_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B512_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B512_extra_packed) == 1, "");
_Static_assert(sizeof(struct B512_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B512_extra_size) == 6, "");
_Static_assert(_Alignof(struct B512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B512,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B512,e) == 0, "");
#endif
_Static_assert(sizeof(B513) == 4, "");
_Static_assert(_Alignof(B513) == 4, "");
_Static_assert(sizeof(struct B513_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B513_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B513_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B513_extra_packed) == 1, "");
_Static_assert(sizeof(struct B513_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B513_extra_size) == 6, "");
_Static_assert(_Alignof(struct B513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B513,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B513,e) == 0, "");
#endif
_Static_assert(sizeof(B514) == 4, "");
_Static_assert(_Alignof(B514) == 4, "");
_Static_assert(sizeof(struct B514_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B514_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B514_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B514_extra_packed) == 1, "");
_Static_assert(sizeof(struct B514_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B514_extra_size) == 6, "");
_Static_assert(_Alignof(struct B514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B514,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B514,e) == 0, "");
#endif
_Static_assert(sizeof(B515) == 4, "");
_Static_assert(_Alignof(B515) == 1, "");
_Static_assert(sizeof(struct B515_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B515_extra_packed) == 1, "");
_Static_assert(sizeof(struct B515_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_size) == 6, "");
_Static_assert(_Alignof(struct B515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B515,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B515,e) == 0, "");
#endif
_Static_assert(sizeof(B516) == 4, "");
_Static_assert(_Alignof(B516) == 1, "");
_Static_assert(sizeof(struct B516_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B516_extra_packed) == 1, "");
_Static_assert(sizeof(struct B516_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_size) == 6, "");
_Static_assert(_Alignof(struct B516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B516,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B516,e) == 0, "");
#endif
_Static_assert(sizeof(B517) == 4, "");
_Static_assert(_Alignof(B517) == 2, "");
_Static_assert(sizeof(struct B517_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B517_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B517_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B517_extra_packed) == 1, "");
_Static_assert(sizeof(struct B517_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_size) == 6, "");
_Static_assert(_Alignof(struct B517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B517,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B517,e) == 0, "");
#endif
_Static_assert(sizeof(B518) == 4, "");
_Static_assert(_Alignof(B518) == 4, "");
_Static_assert(sizeof(struct B518_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B518_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B518_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B518_extra_packed) == 1, "");
_Static_assert(sizeof(struct B518_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_size) == 6, "");
_Static_assert(_Alignof(struct B518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B518,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B518,e) == 0, "");
#endif
_Static_assert(sizeof(B519) == 4, "");
_Static_assert(_Alignof(B519) == 4, "");
_Static_assert(sizeof(struct B519_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B519_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B519_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B519_extra_packed) == 1, "");
_Static_assert(sizeof(struct B519_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_size) == 6, "");
_Static_assert(_Alignof(struct B519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B519,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B519,e) == 0, "");
#endif
// MAPPING|FOUR|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|riscv32-baseline_rv32-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|x86_64-x86_64-linux-gnux32:Gcc|END
// repr targets ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32")
#elif defined(FOUR)
_Static_assert(sizeof(A000) == 4, "");
_Static_assert(_Alignof(A000) == 2, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 6, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A000,e) == 17, "");
#endif
_Static_assert(sizeof(A001) == 2, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 4, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A001,e) == 9, "");
#endif
_Static_assert(sizeof(A002) == 4, "");
_Static_assert(_Alignof(A002) == 2, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A002_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 6, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A002,e) == 17, "");
#endif
_Static_assert(sizeof(A003) == 8, "");
_Static_assert(_Alignof(A003) == 4, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A003_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 10, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A003,e) == 33, "");
#endif
_Static_assert(sizeof(A004) == 8, "");
_Static_assert(_Alignof(A004) == 4, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A004_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 10, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A004,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A004,e) == 33, "");
#endif
_Static_assert(sizeof(A005) == 4, "");
_Static_assert(_Alignof(A005) == 2, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A005_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 6, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A005,e) == 17, "");
#endif
_Static_assert(sizeof(A006) == 2, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 4, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A006,e) == 9, "");
#endif
_Static_assert(sizeof(A007) == 4, "");
_Static_assert(_Alignof(A007) == 2, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A007_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 6, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A007,e) == 17, "");
#endif
_Static_assert(sizeof(A008) == 8, "");
_Static_assert(_Alignof(A008) == 4, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A008_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 10, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A008,e) == 33, "");
#endif
_Static_assert(sizeof(A009) == 8, "");
_Static_assert(_Alignof(A009) == 4, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A009_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 10, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A009,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A009,e) == 33, "");
#endif
_Static_assert(sizeof(A010) == 4, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 6, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A010,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A010,e) == 24, "");
#endif
_Static_assert(sizeof(A011) == 3, "");
_Static_assert(_Alignof(A011) == 1, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 5, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A011,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A011,e) == 16, "");
#endif
_Static_assert(sizeof(A012) == 4, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 6, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A012,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A012,e) == 24, "");
#endif
_Static_assert(sizeof(A013) == 8, "");
_Static_assert(_Alignof(A013) == 4, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A013_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 10, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A013,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A013,e) == 40, "");
#endif
_Static_assert(sizeof(A014) == 8, "");
_Static_assert(_Alignof(A014) == 4, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A014_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 10, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A014,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A014,e) == 40, "");
#endif
_Static_assert(sizeof(A015) == 4, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 6, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A015,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A015,e) == 24, "");
#endif
_Static_assert(sizeof(A016) == 3, "");
_Static_assert(_Alignof(A016) == 1, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 5, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A016,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A016,e) == 16, "");
#endif
_Static_assert(sizeof(A017) == 4, "");
_Static_assert(_Alignof(A017) == 2, "");
_Static_assert(sizeof(struct A017_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A017_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A017_extra_packed) == 1, "");
_Static_assert(sizeof(struct A017_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A017_extra_size) == 6, "");
_Static_assert(_Alignof(struct A017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A017,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A017,e) == 24, "");
#endif
_Static_assert(sizeof(A018) == 8, "");
_Static_assert(_Alignof(A018) == 4, "");
_Static_assert(sizeof(struct A018_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A018_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A018_extra_packed) == 1, "");
_Static_assert(sizeof(struct A018_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A018_extra_size) == 10, "");
_Static_assert(_Alignof(struct A018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A018,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A018,e) == 40, "");
#endif
_Static_assert(sizeof(A019) == 8, "");
_Static_assert(_Alignof(A019) == 4, "");
_Static_assert(sizeof(struct A019_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A019_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A019_extra_packed) == 1, "");
_Static_assert(sizeof(struct A019_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A019_extra_size) == 10, "");
_Static_assert(_Alignof(struct A019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A019,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A019,e) == 40, "");
#endif
_Static_assert(sizeof(A100) == 4, "");
_Static_assert(_Alignof(A100) == 4, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 6, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A100,e) == 17, "");
#endif
_Static_assert(sizeof(A101) == 2, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 4, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A101,e) == 9, "");
#endif
_Static_assert(sizeof(A102) == 4, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 6, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A102,e) == 17, "");
#endif
_Static_assert(sizeof(A103) == 8, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 10, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A103,e) == 33, "");
#endif
_Static_assert(sizeof(A104) == 8, "");
_Static_assert(_Alignof(A104) == 4, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A104_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 10, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A104,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A104,e) == 33, "");
#endif
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A105,e) == 17, "");
#endif
_Static_assert(sizeof(A106) == 2, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 4, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A106,e) == 9, "");
#endif
_Static_assert(sizeof(A107) == 4, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 6, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A107,e) == 17, "");
#endif
_Static_assert(sizeof(A108) == 8, "");
_Static_assert(_Alignof(A108) == 4, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A108_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 10, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A108,e) == 33, "");
#endif
_Static_assert(sizeof(A109) == 8, "");
_Static_assert(_Alignof(A109) == 4, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A109_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 10, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A109,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A109,e) == 33, "");
#endif
_Static_assert(sizeof(A110) == 8, "");
_Static_assert(_Alignof(A110) == 4, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A110_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 10, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A110,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A110,e) == 63, "");
#endif
_Static_assert(sizeof(A111) == 5, "");
_Static_assert(_Alignof(A111) == 1, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 7, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A111,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A111,e) == 39, "");
#endif
_Static_assert(sizeof(A112) == 6, "");
_Static_assert(_Alignof(A112) == 2, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A112_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 8, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A112,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A112,e) == 47, "");
#endif
_Static_assert(sizeof(A113) == 8, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 10, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A113,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A113,e) == 63, "");
#endif
_Static_assert(sizeof(A114) == 8, "");
_Static_assert(_Alignof(A114) == 4, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A114_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 10, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A114,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A114,e) == 63, "");
#endif
_Static_assert(sizeof(A115) == 6, "");
_Static_assert(_Alignof(A115) == 2, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A115_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 8, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A115,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A115,e) == 47, "");
#endif
_Static_assert(sizeof(A116) == 5, "");
_Static_assert(_Alignof(A116) == 1, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 7, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A116,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A116,e) == 39, "");
#endif
_Static_assert(sizeof(A117) == 6, "");
_Static_assert(_Alignof(A117) == 2, "");
_Static_assert(sizeof(struct A117_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A117_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A117_extra_packed) == 1, "");
_Static_assert(sizeof(struct A117_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A117_extra_size) == 8, "");
_Static_assert(_Alignof(struct A117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A117,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A117,e) == 47, "");
#endif
_Static_assert(sizeof(A118) == 8, "");
_Static_assert(_Alignof(A118) == 4, "");
_Static_assert(sizeof(struct A118_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A118_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A118_extra_packed) == 1, "");
_Static_assert(sizeof(struct A118_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A118_extra_size) == 10, "");
_Static_assert(_Alignof(struct A118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A118,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A118,e) == 63, "");
#endif
_Static_assert(sizeof(A119) == 8, "");
_Static_assert(_Alignof(A119) == 4, "");
_Static_assert(sizeof(struct A119_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A119_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A119_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A119_extra_packed) == 1, "");
_Static_assert(sizeof(struct A119_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A119_extra_size) == 10, "");
_Static_assert(_Alignof(struct A119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A119,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A119,e) == 63, "");
#endif
_Static_assert(sizeof(A200) == 1, "");
_Static_assert(_Alignof(A200) == 1, "");
_Static_assert(sizeof(struct A200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A200_extra_packed) == 1, "");
_Static_assert(sizeof(struct A200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_size) == 3, "");
_Static_assert(_Alignof(struct A200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A200,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A200,e) == 2, "");
#endif
_Static_assert(sizeof(A201) == 1, "");
_Static_assert(_Alignof(A201) == 1, "");
_Static_assert(sizeof(struct A201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A201_extra_packed) == 1, "");
_Static_assert(sizeof(struct A201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_size) == 3, "");
_Static_assert(_Alignof(struct A201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A201,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A201,e) == 2, "");
#endif
_Static_assert(sizeof(A202) == 1, "");
_Static_assert(_Alignof(A202) == 1, "");
_Static_assert(sizeof(struct A202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A202_extra_packed) == 1, "");
_Static_assert(sizeof(struct A202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_size) == 3, "");
_Static_assert(_Alignof(struct A202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A202,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A202,e) == 2, "");
#endif
_Static_assert(sizeof(A203) == 1, "");
_Static_assert(_Alignof(A203) == 1, "");
_Static_assert(sizeof(struct A203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A203_extra_packed) == 1, "");
_Static_assert(sizeof(struct A203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_size) == 3, "");
_Static_assert(_Alignof(struct A203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A203,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A203,e) == 2, "");
#endif
_Static_assert(sizeof(A204) == 1, "");
_Static_assert(_Alignof(A204) == 1, "");
_Static_assert(sizeof(struct A204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A204_extra_packed) == 1, "");
_Static_assert(sizeof(struct A204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_size) == 3, "");
_Static_assert(_Alignof(struct A204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A204,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A204,e) == 2, "");
#endif
_Static_assert(sizeof(A205) == 1, "");
_Static_assert(_Alignof(A205) == 1, "");
_Static_assert(sizeof(struct A205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A205_extra_packed) == 1, "");
_Static_assert(sizeof(struct A205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_size) == 3, "");
_Static_assert(_Alignof(struct A205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A205,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A205,e) == 2, "");
#endif
_Static_assert(sizeof(A206) == 1, "");
_Static_assert(_Alignof(A206) == 1, "");
_Static_assert(sizeof(struct A206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A206_extra_packed) == 1, "");
_Static_assert(sizeof(struct A206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_size) == 3, "");
_Static_assert(_Alignof(struct A206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A206,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A206,e) == 2, "");
#endif
_Static_assert(sizeof(A207) == 1, "");
_Static_assert(_Alignof(A207) == 1, "");
_Static_assert(sizeof(struct A207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A207_extra_packed) == 1, "");
_Static_assert(sizeof(struct A207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_size) == 3, "");
_Static_assert(_Alignof(struct A207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A207,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A207,e) == 2, "");
#endif
_Static_assert(sizeof(A208) == 1, "");
_Static_assert(_Alignof(A208) == 1, "");
_Static_assert(sizeof(struct A208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A208_extra_packed) == 1, "");
_Static_assert(sizeof(struct A208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_size) == 3, "");
_Static_assert(_Alignof(struct A208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A208,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A208,e) == 2, "");
#endif
_Static_assert(sizeof(A209) == 1, "");
_Static_assert(_Alignof(A209) == 1, "");
_Static_assert(sizeof(struct A209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A209_extra_packed) == 1, "");
_Static_assert(sizeof(struct A209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_size) == 3, "");
_Static_assert(_Alignof(struct A209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A209,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A209,e) == 2, "");
#endif
_Static_assert(sizeof(A210) == 3, "");
_Static_assert(_Alignof(A210) == 1, "");
_Static_assert(sizeof(struct A210_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A210_extra_packed) == 1, "");
_Static_assert(sizeof(struct A210_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_size) == 5, "");
_Static_assert(_Alignof(struct A210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A210,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A210,e) == 16, "");
#endif
_Static_assert(sizeof(A211) == 2, "");
_Static_assert(_Alignof(A211) == 1, "");
_Static_assert(sizeof(struct A211_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A211_extra_packed) == 1, "");
_Static_assert(sizeof(struct A211_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_size) == 4, "");
_Static_assert(_Alignof(struct A211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A211,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A211,e) == 9, "");
#endif
_Static_assert(sizeof(A212) == 2, "");
_Static_assert(_Alignof(A212) == 1, "");
_Static_assert(sizeof(struct A212_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A212_extra_packed) == 1, "");
_Static_assert(sizeof(struct A212_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_size) == 4, "");
_Static_assert(_Alignof(struct A212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A212,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A212,e) == 9, "");
#endif
_Static_assert(sizeof(A213) == 2, "");
_Static_assert(_Alignof(A213) == 1, "");
_Static_assert(sizeof(struct A213_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A213_extra_packed) == 1, "");
_Static_assert(sizeof(struct A213_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_size) == 4, "");
_Static_assert(_Alignof(struct A213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A213,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A213,e) == 9, "");
#endif
_Static_assert(sizeof(A214) == 2, "");
_Static_assert(_Alignof(A214) == 1, "");
_Static_assert(sizeof(struct A214_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A214_extra_packed) == 1, "");
_Static_assert(sizeof(struct A214_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_size) == 4, "");
_Static_assert(_Alignof(struct A214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A214,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A214,e) == 9, "");
#endif
_Static_assert(sizeof(A215) == 2, "");
_Static_assert(_Alignof(A215) == 1, "");
_Static_assert(sizeof(struct A215_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A215_extra_packed) == 1, "");
_Static_assert(sizeof(struct A215_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_size) == 4, "");
_Static_assert(_Alignof(struct A215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A215,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A215,e) == 9, "");
#endif
_Static_assert(sizeof(A216) == 2, "");
_Static_assert(_Alignof(A216) == 1, "");
_Static_assert(sizeof(struct A216_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A216_extra_packed) == 1, "");
_Static_assert(sizeof(struct A216_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_size) == 4, "");
_Static_assert(_Alignof(struct A216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A216,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A216,e) == 9, "");
#endif
_Static_assert(sizeof(A217) == 2, "");
_Static_assert(_Alignof(A217) == 1, "");
_Static_assert(sizeof(struct A217_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A217_extra_packed) == 1, "");
_Static_assert(sizeof(struct A217_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_size) == 4, "");
_Static_assert(_Alignof(struct A217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A217,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A217,e) == 9, "");
#endif
_Static_assert(sizeof(A218) == 2, "");
_Static_assert(_Alignof(A218) == 1, "");
_Static_assert(sizeof(struct A218_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A218_extra_packed) == 1, "");
_Static_assert(sizeof(struct A218_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_size) == 4, "");
_Static_assert(_Alignof(struct A218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A218,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A218,e) == 9, "");
#endif
_Static_assert(sizeof(A219) == 2, "");
_Static_assert(_Alignof(A219) == 1, "");
_Static_assert(sizeof(struct A219_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A219_extra_packed) == 1, "");
_Static_assert(sizeof(struct A219_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_size) == 4, "");
_Static_assert(_Alignof(struct A219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A219,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A219,e) == 9, "");
#endif
_Static_assert(sizeof(A300) == 4, "");
_Static_assert(_Alignof(A300) == 4, "");
_Static_assert(sizeof(struct A300_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A300_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A300_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A300_extra_packed) == 1, "");
_Static_assert(sizeof(struct A300_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A300_extra_size) == 6, "");
_Static_assert(_Alignof(struct A300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A300,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A300,e) == 3, "");
#endif
_Static_assert(sizeof(A301) == 1, "");
_Static_assert(_Alignof(A301) == 1, "");
_Static_assert(sizeof(struct A301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A301_extra_packed) == 1, "");
_Static_assert(sizeof(struct A301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_size) == 3, "");
_Static_assert(_Alignof(struct A301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A301,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A301,e) == 3, "");
#endif
_Static_assert(sizeof(A302) == 2, "");
_Static_assert(_Alignof(A302) == 2, "");
_Static_assert(sizeof(struct A302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A302_extra_packed) == 1, "");
_Static_assert(sizeof(struct A302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A302_extra_size) == 4, "");
_Static_assert(_Alignof(struct A302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A302,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A302,e) == 3, "");
#endif
_Static_assert(sizeof(A303) == 4, "");
_Static_assert(_Alignof(A303) == 4, "");
_Static_assert(sizeof(struct A303_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A303_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A303_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A303_extra_packed) == 1, "");
_Static_assert(sizeof(struct A303_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A303_extra_size) == 6, "");
_Static_assert(_Alignof(struct A303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A303,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A303,e) == 3, "");
#endif
_Static_assert(sizeof(A304) == 4, "");
_Static_assert(_Alignof(A304) == 4, "");
_Static_assert(sizeof(struct A304_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A304_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A304_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A304_extra_packed) == 1, "");
_Static_assert(sizeof(struct A304_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A304_extra_size) == 6, "");
_Static_assert(_Alignof(struct A304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A304,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A304,e) == 3, "");
#endif
_Static_assert(sizeof(A305) == 1, "");
_Static_assert(_Alignof(A305) == 1, "");
_Static_assert(sizeof(struct A305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A305_extra_packed) == 1, "");
_Static_assert(sizeof(struct A305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_size) == 3, "");
_Static_assert(_Alignof(struct A305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A305,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A305,e) == 3, "");
#endif
_Static_assert(sizeof(A306) == 1, "");
_Static_assert(_Alignof(A306) == 1, "");
_Static_assert(sizeof(struct A306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A306_extra_packed) == 1, "");
_Static_assert(sizeof(struct A306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_size) == 3, "");
_Static_assert(_Alignof(struct A306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A306,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A306,e) == 3, "");
#endif
_Static_assert(sizeof(A307) == 2, "");
_Static_assert(_Alignof(A307) == 2, "");
_Static_assert(sizeof(struct A307_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A307_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A307_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A307_extra_packed) == 1, "");
_Static_assert(sizeof(struct A307_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_size) == 4, "");
_Static_assert(_Alignof(struct A307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A307,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A307,e) == 3, "");
#endif
_Static_assert(sizeof(A308) == 4, "");
_Static_assert(_Alignof(A308) == 4, "");
_Static_assert(sizeof(struct A308_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A308_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A308_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A308_extra_packed) == 1, "");
_Static_assert(sizeof(struct A308_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_size) == 6, "");
_Static_assert(_Alignof(struct A308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A308,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A308,e) == 3, "");
#endif
_Static_assert(sizeof(A309) == 4, "");
_Static_assert(_Alignof(A309) == 4, "");
_Static_assert(sizeof(struct A309_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A309_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A309_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A309_extra_packed) == 1, "");
_Static_assert(sizeof(struct A309_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_size) == 6, "");
_Static_assert(_Alignof(struct A309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A309,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A309,e) == 3, "");
#endif
_Static_assert(sizeof(A310) == 8, "");
_Static_assert(_Alignof(A310) == 4, "");
_Static_assert(sizeof(struct A310_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A310_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A310_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A310_extra_packed) == 1, "");
_Static_assert(sizeof(struct A310_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A310_extra_size) == 10, "");
_Static_assert(_Alignof(struct A310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A310,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A310,e) == 63, "");
#endif
_Static_assert(sizeof(A311) == 5, "");
_Static_assert(_Alignof(A311) == 1, "");
_Static_assert(sizeof(struct A311_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A311_extra_packed) == 1, "");
_Static_assert(sizeof(struct A311_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_size) == 7, "");
_Static_assert(_Alignof(struct A311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A311,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A311,e) == 33, "");
#endif
_Static_assert(sizeof(A312) == 6, "");
_Static_assert(_Alignof(A312) == 2, "");
_Static_assert(sizeof(struct A312_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A312_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A312_extra_packed) == 1, "");
_Static_assert(sizeof(struct A312_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A312_extra_size) == 8, "");
_Static_assert(_Alignof(struct A312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A312,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A312,e) == 33, "");
#endif
_Static_assert(sizeof(A313) == 8, "");
_Static_assert(_Alignof(A313) == 4, "");
_Static_assert(sizeof(struct A313_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A313_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A313_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A313_extra_packed) == 1, "");
_Static_assert(sizeof(struct A313_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A313_extra_size) == 10, "");
_Static_assert(_Alignof(struct A313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A313,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A313,e) == 33, "");
#endif
_Static_assert(sizeof(A314) == 8, "");
_Static_assert(_Alignof(A314) == 4, "");
_Static_assert(sizeof(struct A314_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A314_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A314_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A314_extra_packed) == 1, "");
_Static_assert(sizeof(struct A314_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A314_extra_size) == 10, "");
_Static_assert(_Alignof(struct A314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A314,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A314,e) == 33, "");
#endif
_Static_assert(sizeof(A315) == 5, "");
_Static_assert(_Alignof(A315) == 1, "");
_Static_assert(sizeof(struct A315_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A315_extra_packed) == 1, "");
_Static_assert(sizeof(struct A315_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_size) == 7, "");
_Static_assert(_Alignof(struct A315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A315,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A315,e) == 33, "");
#endif
_Static_assert(sizeof(A316) == 5, "");
_Static_assert(_Alignof(A316) == 1, "");
_Static_assert(sizeof(struct A316_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A316_extra_packed) == 1, "");
_Static_assert(sizeof(struct A316_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_size) == 7, "");
_Static_assert(_Alignof(struct A316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A316,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A316,e) == 33, "");
#endif
_Static_assert(sizeof(A317) == 6, "");
_Static_assert(_Alignof(A317) == 2, "");
_Static_assert(sizeof(struct A317_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A317_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A317_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A317_extra_packed) == 1, "");
_Static_assert(sizeof(struct A317_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_size) == 8, "");
_Static_assert(_Alignof(struct A317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A317,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A317,e) == 33, "");
#endif
_Static_assert(sizeof(A318) == 8, "");
_Static_assert(_Alignof(A318) == 4, "");
_Static_assert(sizeof(struct A318_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A318_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A318_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A318_extra_packed) == 1, "");
_Static_assert(sizeof(struct A318_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_size) == 10, "");
_Static_assert(_Alignof(struct A318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A318,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A318,e) == 33, "");
#endif
_Static_assert(sizeof(A319) == 8, "");
_Static_assert(_Alignof(A319) == 4, "");
_Static_assert(sizeof(struct A319_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A319_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A319_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A319_extra_packed) == 1, "");
_Static_assert(sizeof(struct A319_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_size) == 10, "");
_Static_assert(_Alignof(struct A319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A319,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A319,e) == 33, "");
#endif
_Static_assert(sizeof(A410) == 8, "");
_Static_assert(_Alignof(A410) == 4, "");
_Static_assert(sizeof(struct A410_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A410_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A410_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A410_extra_packed) == 1, "");
_Static_assert(sizeof(struct A410_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A410_extra_size) == 10, "");
_Static_assert(_Alignof(struct A410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A410,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A410,e) == 62, "");
#endif
_Static_assert(sizeof(A411) == 5, "");
_Static_assert(_Alignof(A411) == 1, "");
_Static_assert(sizeof(struct A411_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A411_extra_packed) == 1, "");
_Static_assert(sizeof(struct A411_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_size) == 7, "");
_Static_assert(_Alignof(struct A411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A411,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A411,e) == 38, "");
#endif
_Static_assert(sizeof(A412) == 6, "");
_Static_assert(_Alignof(A412) == 2, "");
_Static_assert(sizeof(struct A412_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A412_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A412_extra_packed) == 1, "");
_Static_assert(sizeof(struct A412_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A412_extra_size) == 8, "");
_Static_assert(_Alignof(struct A412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A412,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A412,e) == 46, "");
#endif
_Static_assert(sizeof(A413) == 8, "");
_Static_assert(_Alignof(A413) == 4, "");
_Static_assert(sizeof(struct A413_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A413_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A413_extra_packed) == 1, "");
_Static_assert(sizeof(struct A413_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A413_extra_size) == 10, "");
_Static_assert(_Alignof(struct A413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A413,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A413,e) == 62, "");
#endif
_Static_assert(sizeof(A414) == 8, "");
_Static_assert(_Alignof(A414) == 4, "");
_Static_assert(sizeof(struct A414_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A414_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A414_extra_packed) == 1, "");
_Static_assert(sizeof(struct A414_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A414_extra_size) == 10, "");
_Static_assert(_Alignof(struct A414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A414,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A414,e) == 62, "");
#endif
_Static_assert(sizeof(A415) == 6, "");
_Static_assert(_Alignof(A415) == 2, "");
_Static_assert(sizeof(struct A415_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A415_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A415_extra_packed) == 1, "");
_Static_assert(sizeof(struct A415_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A415_extra_size) == 8, "");
_Static_assert(_Alignof(struct A415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A415,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A415,e) == 46, "");
#endif
_Static_assert(sizeof(A416) == 5, "");
_Static_assert(_Alignof(A416) == 1, "");
_Static_assert(sizeof(struct A416_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A416_extra_packed) == 1, "");
_Static_assert(sizeof(struct A416_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_size) == 7, "");
_Static_assert(_Alignof(struct A416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A416,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A416,e) == 38, "");
#endif
_Static_assert(sizeof(A417) == 6, "");
_Static_assert(_Alignof(A417) == 2, "");
_Static_assert(sizeof(struct A417_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A417_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A417_extra_packed) == 1, "");
_Static_assert(sizeof(struct A417_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A417_extra_size) == 8, "");
_Static_assert(_Alignof(struct A417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A417,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A417,e) == 46, "");
#endif
_Static_assert(sizeof(A418) == 8, "");
_Static_assert(_Alignof(A418) == 4, "");
_Static_assert(sizeof(struct A418_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A418_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A418_extra_packed) == 1, "");
_Static_assert(sizeof(struct A418_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A418_extra_size) == 10, "");
_Static_assert(_Alignof(struct A418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A418,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A418,e) == 62, "");
#endif
_Static_assert(sizeof(A419) == 8, "");
_Static_assert(_Alignof(A419) == 4, "");
_Static_assert(sizeof(struct A419_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A419_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A419_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A419_extra_packed) == 1, "");
_Static_assert(sizeof(struct A419_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A419_extra_size) == 10, "");
_Static_assert(_Alignof(struct A419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A419,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A419,e) == 62, "");
#endif
_Static_assert(sizeof(A510) == 8, "");
_Static_assert(_Alignof(A510) == 4, "");
_Static_assert(sizeof(struct A510_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A510_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A510_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A510_extra_packed) == 1, "");
_Static_assert(sizeof(struct A510_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A510_extra_size) == 10, "");
_Static_assert(_Alignof(struct A510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A510,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A510,e) == 32, "");
#endif
_Static_assert(sizeof(A511) == 5, "");
_Static_assert(_Alignof(A511) == 1, "");
_Static_assert(sizeof(struct A511_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A511_extra_packed) == 1, "");
_Static_assert(sizeof(struct A511_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_size) == 7, "");
_Static_assert(_Alignof(struct A511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A511,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A511,e) == 32, "");
#endif
_Static_assert(sizeof(A512) == 6, "");
_Static_assert(_Alignof(A512) == 2, "");
_Static_assert(sizeof(struct A512_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A512_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A512_extra_packed) == 1, "");
_Static_assert(sizeof(struct A512_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A512_extra_size) == 8, "");
_Static_assert(_Alignof(struct A512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A512,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A512,e) == 32, "");
#endif
_Static_assert(sizeof(A513) == 8, "");
_Static_assert(_Alignof(A513) == 4, "");
_Static_assert(sizeof(struct A513_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A513_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A513_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A513_extra_packed) == 1, "");
_Static_assert(sizeof(struct A513_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A513_extra_size) == 10, "");
_Static_assert(_Alignof(struct A513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A513,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A513,e) == 32, "");
#endif
_Static_assert(sizeof(A514) == 8, "");
_Static_assert(_Alignof(A514) == 4, "");
_Static_assert(sizeof(struct A514_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A514_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A514_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A514_extra_packed) == 1, "");
_Static_assert(sizeof(struct A514_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A514_extra_size) == 10, "");
_Static_assert(_Alignof(struct A514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A514,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A514,e) == 32, "");
#endif
_Static_assert(sizeof(A515) == 5, "");
_Static_assert(_Alignof(A515) == 1, "");
_Static_assert(sizeof(struct A515_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A515_extra_packed) == 1, "");
_Static_assert(sizeof(struct A515_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_size) == 7, "");
_Static_assert(_Alignof(struct A515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A515,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A515,e) == 32, "");
#endif
_Static_assert(sizeof(A516) == 5, "");
_Static_assert(_Alignof(A516) == 1, "");
_Static_assert(sizeof(struct A516_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A516_extra_packed) == 1, "");
_Static_assert(sizeof(struct A516_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_size) == 7, "");
_Static_assert(_Alignof(struct A516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A516,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A516,e) == 32, "");
#endif
_Static_assert(sizeof(A517) == 6, "");
_Static_assert(_Alignof(A517) == 2, "");
_Static_assert(sizeof(struct A517_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A517_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A517_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A517_extra_packed) == 1, "");
_Static_assert(sizeof(struct A517_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_size) == 8, "");
_Static_assert(_Alignof(struct A517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A517,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A517,e) == 32, "");
#endif
_Static_assert(sizeof(A518) == 8, "");
_Static_assert(_Alignof(A518) == 4, "");
_Static_assert(sizeof(struct A518_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A518_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A518_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A518_extra_packed) == 1, "");
_Static_assert(sizeof(struct A518_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_size) == 10, "");
_Static_assert(_Alignof(struct A518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A518,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A518,e) == 32, "");
#endif
_Static_assert(sizeof(A519) == 8, "");
_Static_assert(_Alignof(A519) == 4, "");
_Static_assert(sizeof(struct A519_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A519_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A519_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A519_extra_packed) == 1, "");
_Static_assert(sizeof(struct A519_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_size) == 10, "");
_Static_assert(_Alignof(struct A519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A519,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A519,e) == 32, "");
#endif
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 2, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B000,e) == 0, "");
#endif
_Static_assert(sizeof(B001) == 1, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 3, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B001,e) == 0, "");
#endif
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 2, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B002,e) == 0, "");
#endif
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 4, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B003,e) == 0, "");
#endif
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 4, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B004,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B004,e) == 0, "");
#endif
_Static_assert(sizeof(B005) == 2, "");
_Static_assert(_Alignof(B005) == 2, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B005_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 4, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B005,e) == 0, "");
#endif
_Static_assert(sizeof(B006) == 1, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 3, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B006,e) == 0, "");
#endif
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 2, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B007,e) == 0, "");
#endif
_Static_assert(sizeof(B008) == 4, "");
_Static_assert(_Alignof(B008) == 4, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B008_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 6, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B008,e) == 0, "");
#endif
_Static_assert(sizeof(B009) == 4, "");
_Static_assert(_Alignof(B009) == 4, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B009_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 6, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B009,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B009,e) == 0, "");
#endif
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 2, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B010,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B010,e) == 0, "");
#endif
_Static_assert(sizeof(B011) == 1, "");
_Static_assert(_Alignof(B011) == 1, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 3, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B011,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B011,e) == 0, "");
#endif
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 2, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B012,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B012,e) == 0, "");
#endif
_Static_assert(sizeof(B013) == 4, "");
_Static_assert(_Alignof(B013) == 4, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B013_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 6, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B013,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B013,e) == 0, "");
#endif
_Static_assert(sizeof(B014) == 4, "");
_Static_assert(_Alignof(B014) == 4, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B014_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 6, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B014,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B014,e) == 0, "");
#endif
_Static_assert(sizeof(B015) == 2, "");
_Static_assert(_Alignof(B015) == 2, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 4, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B015,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B015,e) == 0, "");
#endif
_Static_assert(sizeof(B016) == 1, "");
_Static_assert(_Alignof(B016) == 1, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 3, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B016,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B016,e) == 0, "");
#endif
_Static_assert(sizeof(B017) == 2, "");
_Static_assert(_Alignof(B017) == 2, "");
_Static_assert(sizeof(struct B017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B017_extra_packed) == 1, "");
_Static_assert(sizeof(struct B017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B017_extra_size) == 4, "");
_Static_assert(_Alignof(struct B017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B017,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B017,e) == 0, "");
#endif
_Static_assert(sizeof(B018) == 4, "");
_Static_assert(_Alignof(B018) == 4, "");
_Static_assert(sizeof(struct B018_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B018_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B018_extra_packed) == 1, "");
_Static_assert(sizeof(struct B018_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B018_extra_size) == 6, "");
_Static_assert(_Alignof(struct B018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B018,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B018,e) == 0, "");
#endif
_Static_assert(sizeof(B019) == 4, "");
_Static_assert(_Alignof(B019) == 4, "");
_Static_assert(sizeof(struct B019_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B019_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B019_extra_packed) == 1, "");
_Static_assert(sizeof(struct B019_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B019_extra_size) == 6, "");
_Static_assert(_Alignof(struct B019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B019,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B019,e) == 0, "");
#endif
_Static_assert(sizeof(B100) == 4, "");
_Static_assert(_Alignof(B100) == 4, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 6, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B100,e) == 0, "");
#endif
_Static_assert(sizeof(B101) == 1, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 3, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B101,e) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B102,e) == 0, "");
#endif
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B103,e) == 0, "");
#endif
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 4, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B104,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B104,e) == 0, "");
#endif
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B105,e) == 0, "");
#endif
_Static_assert(sizeof(B106) == 1, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 3, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B106,e) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B107,e) == 0, "");
#endif
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 4, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B108,e) == 0, "");
#endif
_Static_assert(sizeof(B109) == 4, "");
_Static_assert(_Alignof(B109) == 4, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 6, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B109,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B109,e) == 0, "");
#endif
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 4, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B110,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B110,e) == 0, "");
#endif
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 1, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B111,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B111,e) == 0, "");
#endif
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 2, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B112,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B112,e) == 0, "");
#endif
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B113,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B113,e) == 0, "");
#endif
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 4, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B114,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B114,e) == 0, "");
#endif
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 2, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B115,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B115,e) == 0, "");
#endif
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 1, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B116,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B116,e) == 0, "");
#endif
_Static_assert(sizeof(B117) == 4, "");
_Static_assert(_Alignof(B117) == 2, "");
_Static_assert(sizeof(struct B117_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B117_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B117_extra_packed) == 1, "");
_Static_assert(sizeof(struct B117_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B117_extra_size) == 6, "");
_Static_assert(_Alignof(struct B117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B117,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B117,e) == 0, "");
#endif
_Static_assert(sizeof(B118) == 4, "");
_Static_assert(_Alignof(B118) == 4, "");
_Static_assert(sizeof(struct B118_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B118_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B118_extra_packed) == 1, "");
_Static_assert(sizeof(struct B118_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B118_extra_size) == 6, "");
_Static_assert(_Alignof(struct B118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B118,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B118,e) == 0, "");
#endif
_Static_assert(sizeof(B119) == 4, "");
_Static_assert(_Alignof(B119) == 4, "");
_Static_assert(sizeof(struct B119_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B119_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B119_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B119_extra_packed) == 1, "");
_Static_assert(sizeof(struct B119_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B119_extra_size) == 6, "");
_Static_assert(_Alignof(struct B119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B119,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B119,e) == 0, "");
#endif
_Static_assert(sizeof(B200) == 1, "");
_Static_assert(_Alignof(B200) == 1, "");
_Static_assert(sizeof(struct B200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B200_extra_packed) == 1, "");
_Static_assert(sizeof(struct B200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_size) == 3, "");
_Static_assert(_Alignof(struct B200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B200,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B200,e) == 0, "");
#endif
_Static_assert(sizeof(B201) == 1, "");
_Static_assert(_Alignof(B201) == 1, "");
_Static_assert(sizeof(struct B201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B201_extra_packed) == 1, "");
_Static_assert(sizeof(struct B201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_size) == 3, "");
_Static_assert(_Alignof(struct B201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B201,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B201,e) == 0, "");
#endif
_Static_assert(sizeof(B202) == 1, "");
_Static_assert(_Alignof(B202) == 1, "");
_Static_assert(sizeof(struct B202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B202_extra_packed) == 1, "");
_Static_assert(sizeof(struct B202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_size) == 3, "");
_Static_assert(_Alignof(struct B202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B202,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B202,e) == 0, "");
#endif
_Static_assert(sizeof(B203) == 1, "");
_Static_assert(_Alignof(B203) == 1, "");
_Static_assert(sizeof(struct B203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B203_extra_packed) == 1, "");
_Static_assert(sizeof(struct B203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_size) == 3, "");
_Static_assert(_Alignof(struct B203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B203,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B203,e) == 0, "");
#endif
_Static_assert(sizeof(B204) == 1, "");
_Static_assert(_Alignof(B204) == 1, "");
_Static_assert(sizeof(struct B204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B204_extra_packed) == 1, "");
_Static_assert(sizeof(struct B204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_size) == 3, "");
_Static_assert(_Alignof(struct B204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B204,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B204,e) == 0, "");
#endif
_Static_assert(sizeof(B205) == 1, "");
_Static_assert(_Alignof(B205) == 1, "");
_Static_assert(sizeof(struct B205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B205_extra_packed) == 1, "");
_Static_assert(sizeof(struct B205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_size) == 3, "");
_Static_assert(_Alignof(struct B205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B205,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B205,e) == 0, "");
#endif
_Static_assert(sizeof(B206) == 1, "");
_Static_assert(_Alignof(B206) == 1, "");
_Static_assert(sizeof(struct B206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B206_extra_packed) == 1, "");
_Static_assert(sizeof(struct B206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_size) == 3, "");
_Static_assert(_Alignof(struct B206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B206,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B206,e) == 0, "");
#endif
_Static_assert(sizeof(B207) == 1, "");
_Static_assert(_Alignof(B207) == 1, "");
_Static_assert(sizeof(struct B207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B207_extra_packed) == 1, "");
_Static_assert(sizeof(struct B207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_size) == 3, "");
_Static_assert(_Alignof(struct B207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B207,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B207,e) == 0, "");
#endif
_Static_assert(sizeof(B208) == 1, "");
_Static_assert(_Alignof(B208) == 1, "");
_Static_assert(sizeof(struct B208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B208_extra_packed) == 1, "");
_Static_assert(sizeof(struct B208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_size) == 3, "");
_Static_assert(_Alignof(struct B208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B208,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B208,e) == 0, "");
#endif
_Static_assert(sizeof(B209) == 1, "");
_Static_assert(_Alignof(B209) == 1, "");
_Static_assert(sizeof(struct B209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B209_extra_packed) == 1, "");
_Static_assert(sizeof(struct B209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_size) == 3, "");
_Static_assert(_Alignof(struct B209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B209,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B209,e) == 0, "");
#endif
_Static_assert(sizeof(B210) == 1, "");
_Static_assert(_Alignof(B210) == 1, "");
_Static_assert(sizeof(struct B210_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B210_extra_packed) == 1, "");
_Static_assert(sizeof(struct B210_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_size) == 3, "");
_Static_assert(_Alignof(struct B210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B210,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B210,e) == 0, "");
#endif
_Static_assert(sizeof(B211) == 1, "");
_Static_assert(_Alignof(B211) == 1, "");
_Static_assert(sizeof(struct B211_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B211_extra_packed) == 1, "");
_Static_assert(sizeof(struct B211_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_size) == 3, "");
_Static_assert(_Alignof(struct B211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B211,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B211,e) == 0, "");
#endif
_Static_assert(sizeof(B212) == 1, "");
_Static_assert(_Alignof(B212) == 1, "");
_Static_assert(sizeof(struct B212_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B212_extra_packed) == 1, "");
_Static_assert(sizeof(struct B212_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_size) == 3, "");
_Static_assert(_Alignof(struct B212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B212,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B212,e) == 0, "");
#endif
_Static_assert(sizeof(B213) == 1, "");
_Static_assert(_Alignof(B213) == 1, "");
_Static_assert(sizeof(struct B213_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B213_extra_packed) == 1, "");
_Static_assert(sizeof(struct B213_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_size) == 3, "");
_Static_assert(_Alignof(struct B213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B213,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B213,e) == 0, "");
#endif
_Static_assert(sizeof(B214) == 1, "");
_Static_assert(_Alignof(B214) == 1, "");
_Static_assert(sizeof(struct B214_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B214_extra_packed) == 1, "");
_Static_assert(sizeof(struct B214_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_size) == 3, "");
_Static_assert(_Alignof(struct B214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B214,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B214,e) == 0, "");
#endif
_Static_assert(sizeof(B215) == 1, "");
_Static_assert(_Alignof(B215) == 1, "");
_Static_assert(sizeof(struct B215_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B215_extra_packed) == 1, "");
_Static_assert(sizeof(struct B215_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_size) == 3, "");
_Static_assert(_Alignof(struct B215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B215,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B215,e) == 0, "");
#endif
_Static_assert(sizeof(B216) == 1, "");
_Static_assert(_Alignof(B216) == 1, "");
_Static_assert(sizeof(struct B216_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B216_extra_packed) == 1, "");
_Static_assert(sizeof(struct B216_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_size) == 3, "");
_Static_assert(_Alignof(struct B216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B216,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B216,e) == 0, "");
#endif
_Static_assert(sizeof(B217) == 1, "");
_Static_assert(_Alignof(B217) == 1, "");
_Static_assert(sizeof(struct B217_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B217_extra_packed) == 1, "");
_Static_assert(sizeof(struct B217_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_size) == 3, "");
_Static_assert(_Alignof(struct B217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B217,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B217,e) == 0, "");
#endif
_Static_assert(sizeof(B218) == 1, "");
_Static_assert(_Alignof(B218) == 1, "");
_Static_assert(sizeof(struct B218_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B218_extra_packed) == 1, "");
_Static_assert(sizeof(struct B218_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_size) == 3, "");
_Static_assert(_Alignof(struct B218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B218,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B218,e) == 0, "");
#endif
_Static_assert(sizeof(B219) == 1, "");
_Static_assert(_Alignof(B219) == 1, "");
_Static_assert(sizeof(struct B219_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B219_extra_packed) == 1, "");
_Static_assert(sizeof(struct B219_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_size) == 3, "");
_Static_assert(_Alignof(struct B219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B219,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B219,e) == 0, "");
#endif
_Static_assert(sizeof(B300) == 4, "");
_Static_assert(_Alignof(B300) == 4, "");
_Static_assert(sizeof(struct B300_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B300_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B300_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B300_extra_packed) == 1, "");
_Static_assert(sizeof(struct B300_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B300_extra_size) == 6, "");
_Static_assert(_Alignof(struct B300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B300,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B300,e) == 0, "");
#endif
_Static_assert(sizeof(B301) == 1, "");
_Static_assert(_Alignof(B301) == 1, "");
_Static_assert(sizeof(struct B301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B301_extra_packed) == 1, "");
_Static_assert(sizeof(struct B301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_size) == 3, "");
_Static_assert(_Alignof(struct B301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B301,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B301,e) == 0, "");
#endif
_Static_assert(sizeof(B302) == 2, "");
_Static_assert(_Alignof(B302) == 2, "");
_Static_assert(sizeof(struct B302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B302_extra_packed) == 1, "");
_Static_assert(sizeof(struct B302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B302_extra_size) == 4, "");
_Static_assert(_Alignof(struct B302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B302,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B302,e) == 0, "");
#endif
_Static_assert(sizeof(B303) == 4, "");
_Static_assert(_Alignof(B303) == 4, "");
_Static_assert(sizeof(struct B303_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B303_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B303_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B303_extra_packed) == 1, "");
_Static_assert(sizeof(struct B303_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B303_extra_size) == 6, "");
_Static_assert(_Alignof(struct B303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B303,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B303,e) == 0, "");
#endif
_Static_assert(sizeof(B304) == 4, "");
_Static_assert(_Alignof(B304) == 4, "");
_Static_assert(sizeof(struct B304_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B304_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B304_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B304_extra_packed) == 1, "");
_Static_assert(sizeof(struct B304_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B304_extra_size) == 6, "");
_Static_assert(_Alignof(struct B304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B304,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B304,e) == 0, "");
#endif
_Static_assert(sizeof(B305) == 1, "");
_Static_assert(_Alignof(B305) == 1, "");
_Static_assert(sizeof(struct B305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B305_extra_packed) == 1, "");
_Static_assert(sizeof(struct B305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_size) == 3, "");
_Static_assert(_Alignof(struct B305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B305,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B305,e) == 0, "");
#endif
_Static_assert(sizeof(B306) == 1, "");
_Static_assert(_Alignof(B306) == 1, "");
_Static_assert(sizeof(struct B306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B306_extra_packed) == 1, "");
_Static_assert(sizeof(struct B306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_size) == 3, "");
_Static_assert(_Alignof(struct B306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B306,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B306,e) == 0, "");
#endif
_Static_assert(sizeof(B307) == 2, "");
_Static_assert(_Alignof(B307) == 2, "");
_Static_assert(sizeof(struct B307_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B307_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B307_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B307_extra_packed) == 1, "");
_Static_assert(sizeof(struct B307_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_size) == 4, "");
_Static_assert(_Alignof(struct B307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B307,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B307,e) == 0, "");
#endif
_Static_assert(sizeof(B308) == 4, "");
_Static_assert(_Alignof(B308) == 4, "");
_Static_assert(sizeof(struct B308_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B308_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B308_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B308_extra_packed) == 1, "");
_Static_assert(sizeof(struct B308_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_size) == 6, "");
_Static_assert(_Alignof(struct B308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B308,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B308,e) == 0, "");
#endif
_Static_assert(sizeof(B309) == 4, "");
_Static_assert(_Alignof(B309) == 4, "");
_Static_assert(sizeof(struct B309_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B309_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B309_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B309_extra_packed) == 1, "");
_Static_assert(sizeof(struct B309_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_size) == 6, "");
_Static_assert(_Alignof(struct B309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B309,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B309,e) == 0, "");
#endif
_Static_assert(sizeof(B310) == 4, "");
_Static_assert(_Alignof(B310) == 4, "");
_Static_assert(sizeof(struct B310_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B310_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B310_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B310_extra_packed) == 1, "");
_Static_assert(sizeof(struct B310_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B310_extra_size) == 6, "");
_Static_assert(_Alignof(struct B310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B310,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B310,e) == 0, "");
#endif
_Static_assert(sizeof(B311) == 4, "");
_Static_assert(_Alignof(B311) == 1, "");
_Static_assert(sizeof(struct B311_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B311_extra_packed) == 1, "");
_Static_assert(sizeof(struct B311_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_size) == 6, "");
_Static_assert(_Alignof(struct B311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B311,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B311,e) == 0, "");
#endif
_Static_assert(sizeof(B312) == 4, "");
_Static_assert(_Alignof(B312) == 2, "");
_Static_assert(sizeof(struct B312_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B312_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B312_extra_packed) == 1, "");
_Static_assert(sizeof(struct B312_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B312_extra_size) == 6, "");
_Static_assert(_Alignof(struct B312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B312,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B312,e) == 0, "");
#endif
_Static_assert(sizeof(B313) == 4, "");
_Static_assert(_Alignof(B313) == 4, "");
_Static_assert(sizeof(struct B313_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B313_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B313_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B313_extra_packed) == 1, "");
_Static_assert(sizeof(struct B313_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B313_extra_size) == 6, "");
_Static_assert(_Alignof(struct B313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B313,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B313,e) == 0, "");
#endif
_Static_assert(sizeof(B314) == 4, "");
_Static_assert(_Alignof(B314) == 4, "");
_Static_assert(sizeof(struct B314_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B314_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B314_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B314_extra_packed) == 1, "");
_Static_assert(sizeof(struct B314_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B314_extra_size) == 6, "");
_Static_assert(_Alignof(struct B314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B314,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B314,e) == 0, "");
#endif
_Static_assert(sizeof(B315) == 4, "");
_Static_assert(_Alignof(B315) == 1, "");
_Static_assert(sizeof(struct B315_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B315_extra_packed) == 1, "");
_Static_assert(sizeof(struct B315_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_size) == 6, "");
_Static_assert(_Alignof(struct B315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B315,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B315,e) == 0, "");
#endif
_Static_assert(sizeof(B316) == 4, "");
_Static_assert(_Alignof(B316) == 1, "");
_Static_assert(sizeof(struct B316_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B316_extra_packed) == 1, "");
_Static_assert(sizeof(struct B316_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_size) == 6, "");
_Static_assert(_Alignof(struct B316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B316,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B316,e) == 0, "");
#endif
_Static_assert(sizeof(B317) == 4, "");
_Static_assert(_Alignof(B317) == 2, "");
_Static_assert(sizeof(struct B317_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B317_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B317_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B317_extra_packed) == 1, "");
_Static_assert(sizeof(struct B317_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_size) == 6, "");
_Static_assert(_Alignof(struct B317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B317,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B317,e) == 0, "");
#endif
_Static_assert(sizeof(B318) == 4, "");
_Static_assert(_Alignof(B318) == 4, "");
_Static_assert(sizeof(struct B318_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B318_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B318_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B318_extra_packed) == 1, "");
_Static_assert(sizeof(struct B318_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_size) == 6, "");
_Static_assert(_Alignof(struct B318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B318,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B318,e) == 0, "");
#endif
_Static_assert(sizeof(B319) == 4, "");
_Static_assert(_Alignof(B319) == 4, "");
_Static_assert(sizeof(struct B319_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B319_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B319_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B319_extra_packed) == 1, "");
_Static_assert(sizeof(struct B319_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_size) == 6, "");
_Static_assert(_Alignof(struct B319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B319,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B319,e) == 0, "");
#endif
_Static_assert(sizeof(B410) == 4, "");
_Static_assert(_Alignof(B410) == 4, "");
_Static_assert(sizeof(struct B410_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B410_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B410_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B410_extra_packed) == 1, "");
_Static_assert(sizeof(struct B410_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B410_extra_size) == 6, "");
_Static_assert(_Alignof(struct B410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B410,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B410,e) == 0, "");
#endif
_Static_assert(sizeof(B411) == 4, "");
_Static_assert(_Alignof(B411) == 1, "");
_Static_assert(sizeof(struct B411_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B411_extra_packed) == 1, "");
_Static_assert(sizeof(struct B411_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_size) == 6, "");
_Static_assert(_Alignof(struct B411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B411,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B411,e) == 0, "");
#endif
_Static_assert(sizeof(B412) == 4, "");
_Static_assert(_Alignof(B412) == 2, "");
_Static_assert(sizeof(struct B412_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B412_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B412_extra_packed) == 1, "");
_Static_assert(sizeof(struct B412_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B412_extra_size) == 6, "");
_Static_assert(_Alignof(struct B412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B412,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B412,e) == 0, "");
#endif
_Static_assert(sizeof(B413) == 4, "");
_Static_assert(_Alignof(B413) == 4, "");
_Static_assert(sizeof(struct B413_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B413_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B413_extra_packed) == 1, "");
_Static_assert(sizeof(struct B413_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B413_extra_size) == 6, "");
_Static_assert(_Alignof(struct B413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B413,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B413,e) == 0, "");
#endif
_Static_assert(sizeof(B414) == 4, "");
_Static_assert(_Alignof(B414) == 4, "");
_Static_assert(sizeof(struct B414_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B414_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B414_extra_packed) == 1, "");
_Static_assert(sizeof(struct B414_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B414_extra_size) == 6, "");
_Static_assert(_Alignof(struct B414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B414,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B414,e) == 0, "");
#endif
_Static_assert(sizeof(B415) == 4, "");
_Static_assert(_Alignof(B415) == 2, "");
_Static_assert(sizeof(struct B415_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B415_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B415_extra_packed) == 1, "");
_Static_assert(sizeof(struct B415_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B415_extra_size) == 6, "");
_Static_assert(_Alignof(struct B415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B415,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B415,e) == 0, "");
#endif
_Static_assert(sizeof(B416) == 4, "");
_Static_assert(_Alignof(B416) == 1, "");
_Static_assert(sizeof(struct B416_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B416_extra_packed) == 1, "");
_Static_assert(sizeof(struct B416_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_size) == 6, "");
_Static_assert(_Alignof(struct B416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B416,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B416,e) == 0, "");
#endif
_Static_assert(sizeof(B417) == 4, "");
_Static_assert(_Alignof(B417) == 2, "");
_Static_assert(sizeof(struct B417_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B417_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B417_extra_packed) == 1, "");
_Static_assert(sizeof(struct B417_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B417_extra_size) == 6, "");
_Static_assert(_Alignof(struct B417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B417,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B417,e) == 0, "");
#endif
_Static_assert(sizeof(B418) == 4, "");
_Static_assert(_Alignof(B418) == 4, "");
_Static_assert(sizeof(struct B418_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B418_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B418_extra_packed) == 1, "");
_Static_assert(sizeof(struct B418_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B418_extra_size) == 6, "");
_Static_assert(_Alignof(struct B418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B418,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B418,e) == 0, "");
#endif
_Static_assert(sizeof(B419) == 4, "");
_Static_assert(_Alignof(B419) == 4, "");
_Static_assert(sizeof(struct B419_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B419_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B419_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B419_extra_packed) == 1, "");
_Static_assert(sizeof(struct B419_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B419_extra_size) == 6, "");
_Static_assert(_Alignof(struct B419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B419,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B419,e) == 0, "");
#endif
_Static_assert(sizeof(B510) == 4, "");
_Static_assert(_Alignof(B510) == 4, "");
_Static_assert(sizeof(struct B510_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B510_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B510_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B510_extra_packed) == 1, "");
_Static_assert(sizeof(struct B510_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B510_extra_size) == 6, "");
_Static_assert(_Alignof(struct B510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B510,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B510,e) == 0, "");
#endif
_Static_assert(sizeof(B511) == 4, "");
_Static_assert(_Alignof(B511) == 1, "");
_Static_assert(sizeof(struct B511_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B511_extra_packed) == 1, "");
_Static_assert(sizeof(struct B511_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_size) == 6, "");
_Static_assert(_Alignof(struct B511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B511,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B511,e) == 0, "");
#endif
_Static_assert(sizeof(B512) == 4, "");
_Static_assert(_Alignof(B512) == 2, "");
_Static_assert(sizeof(struct B512_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B512_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B512_extra_packed) == 1, "");
_Static_assert(sizeof(struct B512_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B512_extra_size) == 6, "");
_Static_assert(_Alignof(struct B512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B512,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B512,e) == 0, "");
#endif
_Static_assert(sizeof(B513) == 4, "");
_Static_assert(_Alignof(B513) == 4, "");
_Static_assert(sizeof(struct B513_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B513_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B513_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B513_extra_packed) == 1, "");
_Static_assert(sizeof(struct B513_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B513_extra_size) == 6, "");
_Static_assert(_Alignof(struct B513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B513,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B513,e) == 0, "");
#endif
_Static_assert(sizeof(B514) == 4, "");
_Static_assert(_Alignof(B514) == 4, "");
_Static_assert(sizeof(struct B514_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B514_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B514_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B514_extra_packed) == 1, "");
_Static_assert(sizeof(struct B514_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B514_extra_size) == 6, "");
_Static_assert(_Alignof(struct B514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B514,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B514,e) == 0, "");
#endif
_Static_assert(sizeof(B515) == 4, "");
_Static_assert(_Alignof(B515) == 1, "");
_Static_assert(sizeof(struct B515_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B515_extra_packed) == 1, "");
_Static_assert(sizeof(struct B515_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_size) == 6, "");
_Static_assert(_Alignof(struct B515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B515,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B515,e) == 0, "");
#endif
_Static_assert(sizeof(B516) == 4, "");
_Static_assert(_Alignof(B516) == 1, "");
_Static_assert(sizeof(struct B516_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B516_extra_packed) == 1, "");
_Static_assert(sizeof(struct B516_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_size) == 6, "");
_Static_assert(_Alignof(struct B516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B516,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B516,e) == 0, "");
#endif
_Static_assert(sizeof(B517) == 4, "");
_Static_assert(_Alignof(B517) == 2, "");
_Static_assert(sizeof(struct B517_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B517_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B517_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B517_extra_packed) == 1, "");
_Static_assert(sizeof(struct B517_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_size) == 6, "");
_Static_assert(_Alignof(struct B517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B517,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B517,e) == 0, "");
#endif
_Static_assert(sizeof(B518) == 4, "");
_Static_assert(_Alignof(B518) == 4, "");
_Static_assert(sizeof(struct B518_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B518_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B518_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B518_extra_packed) == 1, "");
_Static_assert(sizeof(struct B518_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_size) == 6, "");
_Static_assert(_Alignof(struct B518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B518,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B518,e) == 0, "");
#endif
_Static_assert(sizeof(B519) == 4, "");
_Static_assert(_Alignof(B519) == 4, "");
_Static_assert(sizeof(struct B519_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B519_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B519_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B519_extra_packed) == 1, "");
_Static_assert(sizeof(struct B519_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_size) == 6, "");
_Static_assert(_Alignof(struct B519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B519,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B519,e) == 0, "");
#endif
// MAPPING|FIVE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(FIVE)
_Static_assert(sizeof(A000) == 4, "");
_Static_assert(_Alignof(A000) == 2, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 6, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A000,e) == 17, "");
#endif
_Static_assert(sizeof(A001) == 1, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 3, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A001,e) == 2, "");
#endif
_Static_assert(sizeof(A002) == 2, "");
_Static_assert(_Alignof(A002) == 2, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 4, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A002,e) == 2, "");
#endif
_Static_assert(sizeof(A003) == 8, "");
_Static_assert(_Alignof(A003) == 4, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A003_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 10, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A003,e) == 33, "");
#endif
_Static_assert(sizeof(A004) == 8, "");
_Static_assert(_Alignof(A004) == 4, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A004_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 10, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A004,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A004,e) == 33, "");
#endif
_Static_assert(sizeof(A005) == 4, "");
_Static_assert(_Alignof(A005) == 2, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A005_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 6, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A005,e) == 17, "");
#endif
_Static_assert(sizeof(A006) == 1, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 3, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A006,e) == 2, "");
#endif
_Static_assert(sizeof(A007) == 2, "");
_Static_assert(_Alignof(A007) == 2, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 4, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A007,e) == 2, "");
#endif
_Static_assert(sizeof(A008) == 8, "");
_Static_assert(_Alignof(A008) == 4, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A008_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 10, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A008,e) == 33, "");
#endif
_Static_assert(sizeof(A009) == 8, "");
_Static_assert(_Alignof(A009) == 4, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A009_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 10, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A009,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A009,e) == 33, "");
#endif
_Static_assert(sizeof(A010) == 4, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 6, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A010,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A010,e) == 24, "");
#endif
_Static_assert(sizeof(A011) == 2, "");
_Static_assert(_Alignof(A011) == 1, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 4, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A011,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A011,e) == 9, "");
#endif
_Static_assert(sizeof(A012) == 2, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 4, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A012,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A012,e) == 9, "");
#endif
_Static_assert(sizeof(A013) == 8, "");
_Static_assert(_Alignof(A013) == 4, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A013_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 10, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A013,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A013,e) == 40, "");
#endif
_Static_assert(sizeof(A014) == 8, "");
_Static_assert(_Alignof(A014) == 4, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A014_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 10, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A014,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A014,e) == 40, "");
#endif
_Static_assert(sizeof(A015) == 4, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 6, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A015,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A015,e) == 24, "");
#endif
_Static_assert(sizeof(A016) == 2, "");
_Static_assert(_Alignof(A016) == 1, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 4, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A016,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A016,e) == 9, "");
#endif
_Static_assert(sizeof(A017) == 2, "");
_Static_assert(_Alignof(A017) == 2, "");
_Static_assert(sizeof(struct A017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A017_extra_packed) == 1, "");
_Static_assert(sizeof(struct A017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A017_extra_size) == 4, "");
_Static_assert(_Alignof(struct A017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A017,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A017,e) == 9, "");
#endif
_Static_assert(sizeof(A018) == 8, "");
_Static_assert(_Alignof(A018) == 4, "");
_Static_assert(sizeof(struct A018_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A018_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A018_extra_packed) == 1, "");
_Static_assert(sizeof(struct A018_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A018_extra_size) == 10, "");
_Static_assert(_Alignof(struct A018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A018,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A018,e) == 40, "");
#endif
_Static_assert(sizeof(A019) == 8, "");
_Static_assert(_Alignof(A019) == 4, "");
_Static_assert(sizeof(struct A019_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A019_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A019_extra_packed) == 1, "");
_Static_assert(sizeof(struct A019_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A019_extra_size) == 10, "");
_Static_assert(_Alignof(struct A019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A019,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A019,e) == 40, "");
#endif
_Static_assert(sizeof(A100) == 4, "");
_Static_assert(_Alignof(A100) == 2, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 6, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A100,e) == 17, "");
#endif
_Static_assert(sizeof(A101) == 1, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 3, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A101,e) == 3, "");
#endif
_Static_assert(sizeof(A102) == 2, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 4, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A102,e) == 3, "");
#endif
_Static_assert(sizeof(A103) == 8, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 10, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A103,e) == 33, "");
#endif
_Static_assert(sizeof(A104) == 8, "");
_Static_assert(_Alignof(A104) == 4, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A104_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 10, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A104,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A104,e) == 33, "");
#endif
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A105,e) == 17, "");
#endif
_Static_assert(sizeof(A106) == 1, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 3, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A106,e) == 3, "");
#endif
_Static_assert(sizeof(A107) == 2, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 4, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A107,e) == 3, "");
#endif
_Static_assert(sizeof(A108) == 8, "");
_Static_assert(_Alignof(A108) == 4, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A108_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 10, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A108,e) == 33, "");
#endif
_Static_assert(sizeof(A109) == 8, "");
_Static_assert(_Alignof(A109) == 4, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A109_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 10, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A109,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A109,e) == 33, "");
#endif
_Static_assert(sizeof(A110) == 6, "");
_Static_assert(_Alignof(A110) == 2, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A110_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 8, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A110,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A110,e) == 47, "");
#endif
_Static_assert(sizeof(A111) == 5, "");
_Static_assert(_Alignof(A111) == 1, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 7, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A111,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A111,e) == 33, "");
#endif
_Static_assert(sizeof(A112) == 6, "");
_Static_assert(_Alignof(A112) == 2, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A112_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 8, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A112,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A112,e) == 33, "");
#endif
_Static_assert(sizeof(A113) == 8, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 10, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A113,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A113,e) == 63, "");
#endif
_Static_assert(sizeof(A114) == 8, "");
_Static_assert(_Alignof(A114) == 4, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A114_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 10, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A114,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A114,e) == 63, "");
#endif
_Static_assert(sizeof(A115) == 6, "");
_Static_assert(_Alignof(A115) == 2, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A115_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 8, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A115,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A115,e) == 47, "");
#endif
_Static_assert(sizeof(A116) == 5, "");
_Static_assert(_Alignof(A116) == 1, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 7, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A116,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A116,e) == 33, "");
#endif
_Static_assert(sizeof(A117) == 6, "");
_Static_assert(_Alignof(A117) == 2, "");
_Static_assert(sizeof(struct A117_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A117_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A117_extra_packed) == 1, "");
_Static_assert(sizeof(struct A117_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A117_extra_size) == 8, "");
_Static_assert(_Alignof(struct A117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A117,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A117,e) == 33, "");
#endif
_Static_assert(sizeof(A118) == 8, "");
_Static_assert(_Alignof(A118) == 4, "");
_Static_assert(sizeof(struct A118_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A118_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A118_extra_packed) == 1, "");
_Static_assert(sizeof(struct A118_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A118_extra_size) == 10, "");
_Static_assert(_Alignof(struct A118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A118,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A118,e) == 63, "");
#endif
_Static_assert(sizeof(A119) == 8, "");
_Static_assert(_Alignof(A119) == 4, "");
_Static_assert(sizeof(struct A119_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A119_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A119_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A119_extra_packed) == 1, "");
_Static_assert(sizeof(struct A119_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A119_extra_size) == 10, "");
_Static_assert(_Alignof(struct A119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A119,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A119,e) == 63, "");
#endif
_Static_assert(sizeof(A200) == 1, "");
_Static_assert(_Alignof(A200) == 1, "");
_Static_assert(sizeof(struct A200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A200_extra_packed) == 1, "");
_Static_assert(sizeof(struct A200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_size) == 3, "");
_Static_assert(_Alignof(struct A200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A200,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A200,e) == 2, "");
#endif
_Static_assert(sizeof(A201) == 1, "");
_Static_assert(_Alignof(A201) == 1, "");
_Static_assert(sizeof(struct A201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A201_extra_packed) == 1, "");
_Static_assert(sizeof(struct A201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_size) == 3, "");
_Static_assert(_Alignof(struct A201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A201,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A201,e) == 2, "");
#endif
_Static_assert(sizeof(A202) == 1, "");
_Static_assert(_Alignof(A202) == 1, "");
_Static_assert(sizeof(struct A202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A202_extra_packed) == 1, "");
_Static_assert(sizeof(struct A202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_size) == 3, "");
_Static_assert(_Alignof(struct A202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A202,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A202,e) == 2, "");
#endif
_Static_assert(sizeof(A203) == 1, "");
_Static_assert(_Alignof(A203) == 1, "");
_Static_assert(sizeof(struct A203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A203_extra_packed) == 1, "");
_Static_assert(sizeof(struct A203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_size) == 3, "");
_Static_assert(_Alignof(struct A203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A203,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A203,e) == 2, "");
#endif
_Static_assert(sizeof(A204) == 1, "");
_Static_assert(_Alignof(A204) == 1, "");
_Static_assert(sizeof(struct A204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A204_extra_packed) == 1, "");
_Static_assert(sizeof(struct A204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_size) == 3, "");
_Static_assert(_Alignof(struct A204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A204,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A204,e) == 2, "");
#endif
_Static_assert(sizeof(A205) == 1, "");
_Static_assert(_Alignof(A205) == 1, "");
_Static_assert(sizeof(struct A205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A205_extra_packed) == 1, "");
_Static_assert(sizeof(struct A205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_size) == 3, "");
_Static_assert(_Alignof(struct A205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A205,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A205,e) == 2, "");
#endif
_Static_assert(sizeof(A206) == 1, "");
_Static_assert(_Alignof(A206) == 1, "");
_Static_assert(sizeof(struct A206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A206_extra_packed) == 1, "");
_Static_assert(sizeof(struct A206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_size) == 3, "");
_Static_assert(_Alignof(struct A206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A206,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A206,e) == 2, "");
#endif
_Static_assert(sizeof(A207) == 1, "");
_Static_assert(_Alignof(A207) == 1, "");
_Static_assert(sizeof(struct A207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A207_extra_packed) == 1, "");
_Static_assert(sizeof(struct A207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_size) == 3, "");
_Static_assert(_Alignof(struct A207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A207,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A207,e) == 2, "");
#endif
_Static_assert(sizeof(A208) == 1, "");
_Static_assert(_Alignof(A208) == 1, "");
_Static_assert(sizeof(struct A208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A208_extra_packed) == 1, "");
_Static_assert(sizeof(struct A208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_size) == 3, "");
_Static_assert(_Alignof(struct A208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A208,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A208,e) == 2, "");
#endif
_Static_assert(sizeof(A209) == 1, "");
_Static_assert(_Alignof(A209) == 1, "");
_Static_assert(sizeof(struct A209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A209_extra_packed) == 1, "");
_Static_assert(sizeof(struct A209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_size) == 3, "");
_Static_assert(_Alignof(struct A209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A209,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A209,e) == 2, "");
#endif
_Static_assert(sizeof(A210) == 2, "");
_Static_assert(_Alignof(A210) == 1, "");
_Static_assert(sizeof(struct A210_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A210_extra_packed) == 1, "");
_Static_assert(sizeof(struct A210_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_size) == 4, "");
_Static_assert(_Alignof(struct A210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A210,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A210,e) == 9, "");
#endif
_Static_assert(sizeof(A211) == 2, "");
_Static_assert(_Alignof(A211) == 1, "");
_Static_assert(sizeof(struct A211_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A211_extra_packed) == 1, "");
_Static_assert(sizeof(struct A211_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_size) == 4, "");
_Static_assert(_Alignof(struct A211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A211,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A211,e) == 9, "");
#endif
_Static_assert(sizeof(A212) == 2, "");
_Static_assert(_Alignof(A212) == 1, "");
_Static_assert(sizeof(struct A212_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A212_extra_packed) == 1, "");
_Static_assert(sizeof(struct A212_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_size) == 4, "");
_Static_assert(_Alignof(struct A212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A212,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A212,e) == 9, "");
#endif
_Static_assert(sizeof(A213) == 2, "");
_Static_assert(_Alignof(A213) == 1, "");
_Static_assert(sizeof(struct A213_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A213_extra_packed) == 1, "");
_Static_assert(sizeof(struct A213_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_size) == 4, "");
_Static_assert(_Alignof(struct A213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A213,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A213,e) == 9, "");
#endif
_Static_assert(sizeof(A214) == 2, "");
_Static_assert(_Alignof(A214) == 1, "");
_Static_assert(sizeof(struct A214_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A214_extra_packed) == 1, "");
_Static_assert(sizeof(struct A214_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_size) == 4, "");
_Static_assert(_Alignof(struct A214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A214,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A214,e) == 9, "");
#endif
_Static_assert(sizeof(A215) == 2, "");
_Static_assert(_Alignof(A215) == 1, "");
_Static_assert(sizeof(struct A215_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A215_extra_packed) == 1, "");
_Static_assert(sizeof(struct A215_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_size) == 4, "");
_Static_assert(_Alignof(struct A215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A215,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A215,e) == 9, "");
#endif
_Static_assert(sizeof(A216) == 2, "");
_Static_assert(_Alignof(A216) == 1, "");
_Static_assert(sizeof(struct A216_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A216_extra_packed) == 1, "");
_Static_assert(sizeof(struct A216_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_size) == 4, "");
_Static_assert(_Alignof(struct A216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A216,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A216,e) == 9, "");
#endif
_Static_assert(sizeof(A217) == 2, "");
_Static_assert(_Alignof(A217) == 1, "");
_Static_assert(sizeof(struct A217_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A217_extra_packed) == 1, "");
_Static_assert(sizeof(struct A217_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_size) == 4, "");
_Static_assert(_Alignof(struct A217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A217,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A217,e) == 9, "");
#endif
_Static_assert(sizeof(A218) == 2, "");
_Static_assert(_Alignof(A218) == 1, "");
_Static_assert(sizeof(struct A218_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A218_extra_packed) == 1, "");
_Static_assert(sizeof(struct A218_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_size) == 4, "");
_Static_assert(_Alignof(struct A218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A218,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A218,e) == 9, "");
#endif
_Static_assert(sizeof(A219) == 2, "");
_Static_assert(_Alignof(A219) == 1, "");
_Static_assert(sizeof(struct A219_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A219_extra_packed) == 1, "");
_Static_assert(sizeof(struct A219_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_size) == 4, "");
_Static_assert(_Alignof(struct A219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A219,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A219,e) == 9, "");
#endif
_Static_assert(sizeof(A300) == 1, "");
_Static_assert(_Alignof(A300) == 1, "");
_Static_assert(sizeof(struct A300_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A300_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A300_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A300_extra_packed) == 1, "");
_Static_assert(sizeof(struct A300_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A300_extra_size) == 3, "");
_Static_assert(_Alignof(struct A300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A300,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A300,e) == 3, "");
#endif
_Static_assert(sizeof(A301) == 1, "");
_Static_assert(_Alignof(A301) == 1, "");
_Static_assert(sizeof(struct A301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A301_extra_packed) == 1, "");
_Static_assert(sizeof(struct A301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_size) == 3, "");
_Static_assert(_Alignof(struct A301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A301,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A301,e) == 3, "");
#endif
_Static_assert(sizeof(A302) == 1, "");
_Static_assert(_Alignof(A302) == 1, "");
_Static_assert(sizeof(struct A302_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A302_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A302_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A302_extra_packed) == 1, "");
_Static_assert(sizeof(struct A302_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A302_extra_size) == 3, "");
_Static_assert(_Alignof(struct A302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A302,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A302,e) == 3, "");
#endif
_Static_assert(sizeof(A303) == 1, "");
_Static_assert(_Alignof(A303) == 1, "");
_Static_assert(sizeof(struct A303_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A303_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A303_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A303_extra_packed) == 1, "");
_Static_assert(sizeof(struct A303_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A303_extra_size) == 3, "");
_Static_assert(_Alignof(struct A303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A303,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A303,e) == 3, "");
#endif
_Static_assert(sizeof(A304) == 1, "");
_Static_assert(_Alignof(A304) == 1, "");
_Static_assert(sizeof(struct A304_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A304_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A304_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A304_extra_packed) == 1, "");
_Static_assert(sizeof(struct A304_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A304_extra_size) == 3, "");
_Static_assert(_Alignof(struct A304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A304,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A304,e) == 3, "");
#endif
_Static_assert(sizeof(A305) == 1, "");
_Static_assert(_Alignof(A305) == 1, "");
_Static_assert(sizeof(struct A305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A305_extra_packed) == 1, "");
_Static_assert(sizeof(struct A305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_size) == 3, "");
_Static_assert(_Alignof(struct A305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A305,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A305,e) == 3, "");
#endif
_Static_assert(sizeof(A306) == 1, "");
_Static_assert(_Alignof(A306) == 1, "");
_Static_assert(sizeof(struct A306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A306_extra_packed) == 1, "");
_Static_assert(sizeof(struct A306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_size) == 3, "");
_Static_assert(_Alignof(struct A306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A306,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A306,e) == 3, "");
#endif
_Static_assert(sizeof(A307) == 1, "");
_Static_assert(_Alignof(A307) == 1, "");
_Static_assert(sizeof(struct A307_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A307_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A307_extra_packed) == 1, "");
_Static_assert(sizeof(struct A307_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_size) == 3, "");
_Static_assert(_Alignof(struct A307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A307,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A307,e) == 3, "");
#endif
_Static_assert(sizeof(A308) == 1, "");
_Static_assert(_Alignof(A308) == 1, "");
_Static_assert(sizeof(struct A308_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A308_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A308_extra_packed) == 1, "");
_Static_assert(sizeof(struct A308_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_size) == 3, "");
_Static_assert(_Alignof(struct A308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A308,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A308,e) == 3, "");
#endif
_Static_assert(sizeof(A309) == 1, "");
_Static_assert(_Alignof(A309) == 1, "");
_Static_assert(sizeof(struct A309_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A309_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A309_extra_packed) == 1, "");
_Static_assert(sizeof(struct A309_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_size) == 3, "");
_Static_assert(_Alignof(struct A309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A309,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A309,e) == 3, "");
#endif
_Static_assert(sizeof(A310) == 5, "");
_Static_assert(_Alignof(A310) == 1, "");
_Static_assert(sizeof(struct A310_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A310_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A310_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A310_extra_packed) == 1, "");
_Static_assert(sizeof(struct A310_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A310_extra_size) == 7, "");
_Static_assert(_Alignof(struct A310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A310,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A310,e) == 33, "");
#endif
_Static_assert(sizeof(A311) == 5, "");
_Static_assert(_Alignof(A311) == 1, "");
_Static_assert(sizeof(struct A311_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A311_extra_packed) == 1, "");
_Static_assert(sizeof(struct A311_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_size) == 7, "");
_Static_assert(_Alignof(struct A311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A311,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A311,e) == 33, "");
#endif
_Static_assert(sizeof(A312) == 5, "");
_Static_assert(_Alignof(A312) == 1, "");
_Static_assert(sizeof(struct A312_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A312_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A312_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A312_extra_packed) == 1, "");
_Static_assert(sizeof(struct A312_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A312_extra_size) == 7, "");
_Static_assert(_Alignof(struct A312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A312,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A312,e) == 33, "");
#endif
_Static_assert(sizeof(A313) == 5, "");
_Static_assert(_Alignof(A313) == 1, "");
_Static_assert(sizeof(struct A313_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A313_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A313_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A313_extra_packed) == 1, "");
_Static_assert(sizeof(struct A313_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A313_extra_size) == 7, "");
_Static_assert(_Alignof(struct A313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A313,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A313,e) == 33, "");
#endif
_Static_assert(sizeof(A314) == 5, "");
_Static_assert(_Alignof(A314) == 1, "");
_Static_assert(sizeof(struct A314_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A314_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A314_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A314_extra_packed) == 1, "");
_Static_assert(sizeof(struct A314_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A314_extra_size) == 7, "");
_Static_assert(_Alignof(struct A314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A314,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A314,e) == 33, "");
#endif
_Static_assert(sizeof(A315) == 5, "");
_Static_assert(_Alignof(A315) == 1, "");
_Static_assert(sizeof(struct A315_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A315_extra_packed) == 1, "");
_Static_assert(sizeof(struct A315_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_size) == 7, "");
_Static_assert(_Alignof(struct A315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A315,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A315,e) == 33, "");
#endif
_Static_assert(sizeof(A316) == 5, "");
_Static_assert(_Alignof(A316) == 1, "");
_Static_assert(sizeof(struct A316_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A316_extra_packed) == 1, "");
_Static_assert(sizeof(struct A316_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_size) == 7, "");
_Static_assert(_Alignof(struct A316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A316,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A316,e) == 33, "");
#endif
_Static_assert(sizeof(A317) == 5, "");
_Static_assert(_Alignof(A317) == 1, "");
_Static_assert(sizeof(struct A317_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A317_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A317_extra_packed) == 1, "");
_Static_assert(sizeof(struct A317_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_size) == 7, "");
_Static_assert(_Alignof(struct A317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A317,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A317,e) == 33, "");
#endif
_Static_assert(sizeof(A318) == 5, "");
_Static_assert(_Alignof(A318) == 1, "");
_Static_assert(sizeof(struct A318_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A318_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A318_extra_packed) == 1, "");
_Static_assert(sizeof(struct A318_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_size) == 7, "");
_Static_assert(_Alignof(struct A318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A318,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A318,e) == 33, "");
#endif
_Static_assert(sizeof(A319) == 5, "");
_Static_assert(_Alignof(A319) == 1, "");
_Static_assert(sizeof(struct A319_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A319_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A319_extra_packed) == 1, "");
_Static_assert(sizeof(struct A319_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_size) == 7, "");
_Static_assert(_Alignof(struct A319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A319,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A319,e) == 33, "");
#endif
_Static_assert(sizeof(A410) == 6, "");
_Static_assert(_Alignof(A410) == 2, "");
_Static_assert(sizeof(struct A410_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A410_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A410_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A410_extra_packed) == 1, "");
_Static_assert(sizeof(struct A410_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A410_extra_size) == 8, "");
_Static_assert(_Alignof(struct A410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A410,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A410,e) == 46, "");
#endif
_Static_assert(sizeof(A411) == 5, "");
_Static_assert(_Alignof(A411) == 1, "");
_Static_assert(sizeof(struct A411_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A411_extra_packed) == 1, "");
_Static_assert(sizeof(struct A411_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_size) == 7, "");
_Static_assert(_Alignof(struct A411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A411,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A411,e) == 32, "");
#endif
_Static_assert(sizeof(A412) == 6, "");
_Static_assert(_Alignof(A412) == 2, "");
_Static_assert(sizeof(struct A412_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A412_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A412_extra_packed) == 1, "");
_Static_assert(sizeof(struct A412_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A412_extra_size) == 8, "");
_Static_assert(_Alignof(struct A412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A412,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A412,e) == 32, "");
#endif
_Static_assert(sizeof(A413) == 8, "");
_Static_assert(_Alignof(A413) == 4, "");
_Static_assert(sizeof(struct A413_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A413_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A413_extra_packed) == 1, "");
_Static_assert(sizeof(struct A413_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A413_extra_size) == 10, "");
_Static_assert(_Alignof(struct A413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A413,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A413,e) == 62, "");
#endif
_Static_assert(sizeof(A414) == 8, "");
_Static_assert(_Alignof(A414) == 4, "");
_Static_assert(sizeof(struct A414_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A414_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A414_extra_packed) == 1, "");
_Static_assert(sizeof(struct A414_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A414_extra_size) == 10, "");
_Static_assert(_Alignof(struct A414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A414,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A414,e) == 62, "");
#endif
_Static_assert(sizeof(A415) == 6, "");
_Static_assert(_Alignof(A415) == 2, "");
_Static_assert(sizeof(struct A415_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A415_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A415_extra_packed) == 1, "");
_Static_assert(sizeof(struct A415_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A415_extra_size) == 8, "");
_Static_assert(_Alignof(struct A415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A415,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A415,e) == 46, "");
#endif
_Static_assert(sizeof(A416) == 5, "");
_Static_assert(_Alignof(A416) == 1, "");
_Static_assert(sizeof(struct A416_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A416_extra_packed) == 1, "");
_Static_assert(sizeof(struct A416_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_size) == 7, "");
_Static_assert(_Alignof(struct A416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A416,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A416,e) == 32, "");
#endif
_Static_assert(sizeof(A417) == 6, "");
_Static_assert(_Alignof(A417) == 2, "");
_Static_assert(sizeof(struct A417_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A417_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A417_extra_packed) == 1, "");
_Static_assert(sizeof(struct A417_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A417_extra_size) == 8, "");
_Static_assert(_Alignof(struct A417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A417,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A417,e) == 32, "");
#endif
_Static_assert(sizeof(A418) == 8, "");
_Static_assert(_Alignof(A418) == 4, "");
_Static_assert(sizeof(struct A418_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A418_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A418_extra_packed) == 1, "");
_Static_assert(sizeof(struct A418_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A418_extra_size) == 10, "");
_Static_assert(_Alignof(struct A418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A418,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A418,e) == 62, "");
#endif
_Static_assert(sizeof(A419) == 8, "");
_Static_assert(_Alignof(A419) == 4, "");
_Static_assert(sizeof(struct A419_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A419_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A419_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A419_extra_packed) == 1, "");
_Static_assert(sizeof(struct A419_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A419_extra_size) == 10, "");
_Static_assert(_Alignof(struct A419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A419,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A419,e) == 62, "");
#endif
_Static_assert(sizeof(A510) == 5, "");
_Static_assert(_Alignof(A510) == 1, "");
_Static_assert(sizeof(struct A510_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A510_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A510_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A510_extra_packed) == 1, "");
_Static_assert(sizeof(struct A510_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A510_extra_size) == 7, "");
_Static_assert(_Alignof(struct A510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A510,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A510,e) == 32, "");
#endif
_Static_assert(sizeof(A511) == 5, "");
_Static_assert(_Alignof(A511) == 1, "");
_Static_assert(sizeof(struct A511_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A511_extra_packed) == 1, "");
_Static_assert(sizeof(struct A511_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_size) == 7, "");
_Static_assert(_Alignof(struct A511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A511,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A511,e) == 32, "");
#endif
_Static_assert(sizeof(A512) == 5, "");
_Static_assert(_Alignof(A512) == 1, "");
_Static_assert(sizeof(struct A512_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A512_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A512_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A512_extra_packed) == 1, "");
_Static_assert(sizeof(struct A512_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A512_extra_size) == 7, "");
_Static_assert(_Alignof(struct A512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A512,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A512,e) == 32, "");
#endif
_Static_assert(sizeof(A513) == 5, "");
_Static_assert(_Alignof(A513) == 1, "");
_Static_assert(sizeof(struct A513_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A513_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A513_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A513_extra_packed) == 1, "");
_Static_assert(sizeof(struct A513_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A513_extra_size) == 7, "");
_Static_assert(_Alignof(struct A513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A513,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A513,e) == 32, "");
#endif
_Static_assert(sizeof(A514) == 5, "");
_Static_assert(_Alignof(A514) == 1, "");
_Static_assert(sizeof(struct A514_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A514_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A514_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A514_extra_packed) == 1, "");
_Static_assert(sizeof(struct A514_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A514_extra_size) == 7, "");
_Static_assert(_Alignof(struct A514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A514,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A514,e) == 32, "");
#endif
_Static_assert(sizeof(A515) == 5, "");
_Static_assert(_Alignof(A515) == 1, "");
_Static_assert(sizeof(struct A515_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A515_extra_packed) == 1, "");
_Static_assert(sizeof(struct A515_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_size) == 7, "");
_Static_assert(_Alignof(struct A515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A515,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A515,e) == 32, "");
#endif
_Static_assert(sizeof(A516) == 5, "");
_Static_assert(_Alignof(A516) == 1, "");
_Static_assert(sizeof(struct A516_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A516_extra_packed) == 1, "");
_Static_assert(sizeof(struct A516_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_size) == 7, "");
_Static_assert(_Alignof(struct A516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A516,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A516,e) == 32, "");
#endif
_Static_assert(sizeof(A517) == 5, "");
_Static_assert(_Alignof(A517) == 1, "");
_Static_assert(sizeof(struct A517_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A517_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A517_extra_packed) == 1, "");
_Static_assert(sizeof(struct A517_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_size) == 7, "");
_Static_assert(_Alignof(struct A517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A517,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A517,e) == 32, "");
#endif
_Static_assert(sizeof(A518) == 5, "");
_Static_assert(_Alignof(A518) == 1, "");
_Static_assert(sizeof(struct A518_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A518_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A518_extra_packed) == 1, "");
_Static_assert(sizeof(struct A518_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_size) == 7, "");
_Static_assert(_Alignof(struct A518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A518,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A518,e) == 32, "");
#endif
_Static_assert(sizeof(A519) == 5, "");
_Static_assert(_Alignof(A519) == 1, "");
_Static_assert(sizeof(struct A519_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A519_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A519_extra_packed) == 1, "");
_Static_assert(sizeof(struct A519_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_size) == 7, "");
_Static_assert(_Alignof(struct A519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A519,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A519,e) == 32, "");
#endif
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 2, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B000,e) == 0, "");
#endif
_Static_assert(sizeof(B001) == 1, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 3, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B001,e) == 0, "");
#endif
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 2, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B002,e) == 0, "");
#endif
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 4, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B003,e) == 0, "");
#endif
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 4, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B004,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B004,e) == 0, "");
#endif
_Static_assert(sizeof(B005) == 2, "");
_Static_assert(_Alignof(B005) == 2, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B005_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 4, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B005,e) == 0, "");
#endif
_Static_assert(sizeof(B006) == 1, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 3, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B006,e) == 0, "");
#endif
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 2, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B007,e) == 0, "");
#endif
_Static_assert(sizeof(B008) == 4, "");
_Static_assert(_Alignof(B008) == 4, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B008_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 6, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B008,e) == 0, "");
#endif
_Static_assert(sizeof(B009) == 4, "");
_Static_assert(_Alignof(B009) == 4, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B009_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 6, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B009,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B009,e) == 0, "");
#endif
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 2, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B010,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B010,e) == 0, "");
#endif
_Static_assert(sizeof(B011) == 1, "");
_Static_assert(_Alignof(B011) == 1, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 3, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B011,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B011,e) == 0, "");
#endif
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 2, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B012,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B012,e) == 0, "");
#endif
_Static_assert(sizeof(B013) == 4, "");
_Static_assert(_Alignof(B013) == 4, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B013_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 6, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B013,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B013,e) == 0, "");
#endif
_Static_assert(sizeof(B014) == 4, "");
_Static_assert(_Alignof(B014) == 4, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B014_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 6, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B014,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B014,e) == 0, "");
#endif
_Static_assert(sizeof(B015) == 2, "");
_Static_assert(_Alignof(B015) == 2, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 4, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B015,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B015,e) == 0, "");
#endif
_Static_assert(sizeof(B016) == 1, "");
_Static_assert(_Alignof(B016) == 1, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 3, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B016,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B016,e) == 0, "");
#endif
_Static_assert(sizeof(B017) == 2, "");
_Static_assert(_Alignof(B017) == 2, "");
_Static_assert(sizeof(struct B017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B017_extra_packed) == 1, "");
_Static_assert(sizeof(struct B017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B017_extra_size) == 4, "");
_Static_assert(_Alignof(struct B017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B017,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B017,e) == 0, "");
#endif
_Static_assert(sizeof(B018) == 4, "");
_Static_assert(_Alignof(B018) == 4, "");
_Static_assert(sizeof(struct B018_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B018_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B018_extra_packed) == 1, "");
_Static_assert(sizeof(struct B018_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B018_extra_size) == 6, "");
_Static_assert(_Alignof(struct B018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B018,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B018,e) == 0, "");
#endif
_Static_assert(sizeof(B019) == 4, "");
_Static_assert(_Alignof(B019) == 4, "");
_Static_assert(sizeof(struct B019_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B019_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B019_extra_packed) == 1, "");
_Static_assert(sizeof(struct B019_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B019_extra_size) == 6, "");
_Static_assert(_Alignof(struct B019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B019,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B019,e) == 0, "");
#endif
_Static_assert(sizeof(B100) == 2, "");
_Static_assert(_Alignof(B100) == 2, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B100_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 4, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B100,e) == 0, "");
#endif
_Static_assert(sizeof(B101) == 1, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 3, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B101,e) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B102,e) == 0, "");
#endif
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B103,e) == 0, "");
#endif
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 4, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B104,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B104,e) == 0, "");
#endif
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B105,e) == 0, "");
#endif
_Static_assert(sizeof(B106) == 1, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 3, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B106,e) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B107,e) == 0, "");
#endif
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 4, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B108,e) == 0, "");
#endif
_Static_assert(sizeof(B109) == 4, "");
_Static_assert(_Alignof(B109) == 4, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 6, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B109,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B109,e) == 0, "");
#endif
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 2, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B110,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B110,e) == 0, "");
#endif
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 1, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B111,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B111,e) == 0, "");
#endif
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 2, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B112,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B112,e) == 0, "");
#endif
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B113,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B113,e) == 0, "");
#endif
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 4, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B114,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B114,e) == 0, "");
#endif
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 2, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B115,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B115,e) == 0, "");
#endif
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 1, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B116,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B116,e) == 0, "");
#endif
_Static_assert(sizeof(B117) == 4, "");
_Static_assert(_Alignof(B117) == 2, "");
_Static_assert(sizeof(struct B117_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B117_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B117_extra_packed) == 1, "");
_Static_assert(sizeof(struct B117_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B117_extra_size) == 6, "");
_Static_assert(_Alignof(struct B117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B117,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B117,e) == 0, "");
#endif
_Static_assert(sizeof(B118) == 4, "");
_Static_assert(_Alignof(B118) == 4, "");
_Static_assert(sizeof(struct B118_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B118_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B118_extra_packed) == 1, "");
_Static_assert(sizeof(struct B118_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B118_extra_size) == 6, "");
_Static_assert(_Alignof(struct B118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B118,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B118,e) == 0, "");
#endif
_Static_assert(sizeof(B119) == 4, "");
_Static_assert(_Alignof(B119) == 4, "");
_Static_assert(sizeof(struct B119_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B119_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B119_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B119_extra_packed) == 1, "");
_Static_assert(sizeof(struct B119_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B119_extra_size) == 6, "");
_Static_assert(_Alignof(struct B119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B119,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B119,e) == 0, "");
#endif
_Static_assert(sizeof(B200) == 1, "");
_Static_assert(_Alignof(B200) == 1, "");
_Static_assert(sizeof(struct B200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B200_extra_packed) == 1, "");
_Static_assert(sizeof(struct B200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_size) == 3, "");
_Static_assert(_Alignof(struct B200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B200,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B200,e) == 0, "");
#endif
_Static_assert(sizeof(B201) == 1, "");
_Static_assert(_Alignof(B201) == 1, "");
_Static_assert(sizeof(struct B201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B201_extra_packed) == 1, "");
_Static_assert(sizeof(struct B201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_size) == 3, "");
_Static_assert(_Alignof(struct B201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B201,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B201,e) == 0, "");
#endif
_Static_assert(sizeof(B202) == 1, "");
_Static_assert(_Alignof(B202) == 1, "");
_Static_assert(sizeof(struct B202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B202_extra_packed) == 1, "");
_Static_assert(sizeof(struct B202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_size) == 3, "");
_Static_assert(_Alignof(struct B202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B202,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B202,e) == 0, "");
#endif
_Static_assert(sizeof(B203) == 1, "");
_Static_assert(_Alignof(B203) == 1, "");
_Static_assert(sizeof(struct B203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B203_extra_packed) == 1, "");
_Static_assert(sizeof(struct B203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_size) == 3, "");
_Static_assert(_Alignof(struct B203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B203,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B203,e) == 0, "");
#endif
_Static_assert(sizeof(B204) == 1, "");
_Static_assert(_Alignof(B204) == 1, "");
_Static_assert(sizeof(struct B204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B204_extra_packed) == 1, "");
_Static_assert(sizeof(struct B204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_size) == 3, "");
_Static_assert(_Alignof(struct B204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B204,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B204,e) == 0, "");
#endif
_Static_assert(sizeof(B205) == 1, "");
_Static_assert(_Alignof(B205) == 1, "");
_Static_assert(sizeof(struct B205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B205_extra_packed) == 1, "");
_Static_assert(sizeof(struct B205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_size) == 3, "");
_Static_assert(_Alignof(struct B205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B205,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B205,e) == 0, "");
#endif
_Static_assert(sizeof(B206) == 1, "");
_Static_assert(_Alignof(B206) == 1, "");
_Static_assert(sizeof(struct B206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B206_extra_packed) == 1, "");
_Static_assert(sizeof(struct B206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_size) == 3, "");
_Static_assert(_Alignof(struct B206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B206,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B206,e) == 0, "");
#endif
_Static_assert(sizeof(B207) == 1, "");
_Static_assert(_Alignof(B207) == 1, "");
_Static_assert(sizeof(struct B207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B207_extra_packed) == 1, "");
_Static_assert(sizeof(struct B207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_size) == 3, "");
_Static_assert(_Alignof(struct B207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B207,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B207,e) == 0, "");
#endif
_Static_assert(sizeof(B208) == 1, "");
_Static_assert(_Alignof(B208) == 1, "");
_Static_assert(sizeof(struct B208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B208_extra_packed) == 1, "");
_Static_assert(sizeof(struct B208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_size) == 3, "");
_Static_assert(_Alignof(struct B208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B208,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B208,e) == 0, "");
#endif
_Static_assert(sizeof(B209) == 1, "");
_Static_assert(_Alignof(B209) == 1, "");
_Static_assert(sizeof(struct B209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B209_extra_packed) == 1, "");
_Static_assert(sizeof(struct B209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_size) == 3, "");
_Static_assert(_Alignof(struct B209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B209,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B209,e) == 0, "");
#endif
_Static_assert(sizeof(B210) == 1, "");
_Static_assert(_Alignof(B210) == 1, "");
_Static_assert(sizeof(struct B210_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B210_extra_packed) == 1, "");
_Static_assert(sizeof(struct B210_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_size) == 3, "");
_Static_assert(_Alignof(struct B210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B210,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B210,e) == 0, "");
#endif
_Static_assert(sizeof(B211) == 1, "");
_Static_assert(_Alignof(B211) == 1, "");
_Static_assert(sizeof(struct B211_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B211_extra_packed) == 1, "");
_Static_assert(sizeof(struct B211_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_size) == 3, "");
_Static_assert(_Alignof(struct B211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B211,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B211,e) == 0, "");
#endif
_Static_assert(sizeof(B212) == 1, "");
_Static_assert(_Alignof(B212) == 1, "");
_Static_assert(sizeof(struct B212_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B212_extra_packed) == 1, "");
_Static_assert(sizeof(struct B212_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_size) == 3, "");
_Static_assert(_Alignof(struct B212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B212,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B212,e) == 0, "");
#endif
_Static_assert(sizeof(B213) == 1, "");
_Static_assert(_Alignof(B213) == 1, "");
_Static_assert(sizeof(struct B213_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B213_extra_packed) == 1, "");
_Static_assert(sizeof(struct B213_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_size) == 3, "");
_Static_assert(_Alignof(struct B213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B213,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B213,e) == 0, "");
#endif
_Static_assert(sizeof(B214) == 1, "");
_Static_assert(_Alignof(B214) == 1, "");
_Static_assert(sizeof(struct B214_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B214_extra_packed) == 1, "");
_Static_assert(sizeof(struct B214_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_size) == 3, "");
_Static_assert(_Alignof(struct B214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B214,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B214,e) == 0, "");
#endif
_Static_assert(sizeof(B215) == 1, "");
_Static_assert(_Alignof(B215) == 1, "");
_Static_assert(sizeof(struct B215_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B215_extra_packed) == 1, "");
_Static_assert(sizeof(struct B215_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_size) == 3, "");
_Static_assert(_Alignof(struct B215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B215,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B215,e) == 0, "");
#endif
_Static_assert(sizeof(B216) == 1, "");
_Static_assert(_Alignof(B216) == 1, "");
_Static_assert(sizeof(struct B216_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B216_extra_packed) == 1, "");
_Static_assert(sizeof(struct B216_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_size) == 3, "");
_Static_assert(_Alignof(struct B216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B216,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B216,e) == 0, "");
#endif
_Static_assert(sizeof(B217) == 1, "");
_Static_assert(_Alignof(B217) == 1, "");
_Static_assert(sizeof(struct B217_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B217_extra_packed) == 1, "");
_Static_assert(sizeof(struct B217_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_size) == 3, "");
_Static_assert(_Alignof(struct B217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B217,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B217,e) == 0, "");
#endif
_Static_assert(sizeof(B218) == 1, "");
_Static_assert(_Alignof(B218) == 1, "");
_Static_assert(sizeof(struct B218_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B218_extra_packed) == 1, "");
_Static_assert(sizeof(struct B218_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_size) == 3, "");
_Static_assert(_Alignof(struct B218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B218,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B218,e) == 0, "");
#endif
_Static_assert(sizeof(B219) == 1, "");
_Static_assert(_Alignof(B219) == 1, "");
_Static_assert(sizeof(struct B219_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B219_extra_packed) == 1, "");
_Static_assert(sizeof(struct B219_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_size) == 3, "");
_Static_assert(_Alignof(struct B219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B219,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B219,e) == 0, "");
#endif
_Static_assert(sizeof(B300) == 1, "");
_Static_assert(_Alignof(B300) == 1, "");
_Static_assert(sizeof(struct B300_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B300_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B300_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B300_extra_packed) == 1, "");
_Static_assert(sizeof(struct B300_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B300_extra_size) == 3, "");
_Static_assert(_Alignof(struct B300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B300,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B300,e) == 0, "");
#endif
_Static_assert(sizeof(B301) == 1, "");
_Static_assert(_Alignof(B301) == 1, "");
_Static_assert(sizeof(struct B301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B301_extra_packed) == 1, "");
_Static_assert(sizeof(struct B301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_size) == 3, "");
_Static_assert(_Alignof(struct B301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B301,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B301,e) == 0, "");
#endif
_Static_assert(sizeof(B302) == 1, "");
_Static_assert(_Alignof(B302) == 1, "");
_Static_assert(sizeof(struct B302_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B302_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B302_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B302_extra_packed) == 1, "");
_Static_assert(sizeof(struct B302_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B302_extra_size) == 3, "");
_Static_assert(_Alignof(struct B302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B302,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B302,e) == 0, "");
#endif
_Static_assert(sizeof(B303) == 1, "");
_Static_assert(_Alignof(B303) == 1, "");
_Static_assert(sizeof(struct B303_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B303_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B303_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B303_extra_packed) == 1, "");
_Static_assert(sizeof(struct B303_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B303_extra_size) == 3, "");
_Static_assert(_Alignof(struct B303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B303,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B303,e) == 0, "");
#endif
_Static_assert(sizeof(B304) == 1, "");
_Static_assert(_Alignof(B304) == 1, "");
_Static_assert(sizeof(struct B304_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B304_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B304_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B304_extra_packed) == 1, "");
_Static_assert(sizeof(struct B304_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B304_extra_size) == 3, "");
_Static_assert(_Alignof(struct B304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B304,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B304,e) == 0, "");
#endif
_Static_assert(sizeof(B305) == 1, "");
_Static_assert(_Alignof(B305) == 1, "");
_Static_assert(sizeof(struct B305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B305_extra_packed) == 1, "");
_Static_assert(sizeof(struct B305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_size) == 3, "");
_Static_assert(_Alignof(struct B305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B305,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B305,e) == 0, "");
#endif
_Static_assert(sizeof(B306) == 1, "");
_Static_assert(_Alignof(B306) == 1, "");
_Static_assert(sizeof(struct B306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B306_extra_packed) == 1, "");
_Static_assert(sizeof(struct B306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_size) == 3, "");
_Static_assert(_Alignof(struct B306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B306,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B306,e) == 0, "");
#endif
_Static_assert(sizeof(B307) == 1, "");
_Static_assert(_Alignof(B307) == 1, "");
_Static_assert(sizeof(struct B307_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B307_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B307_extra_packed) == 1, "");
_Static_assert(sizeof(struct B307_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_size) == 3, "");
_Static_assert(_Alignof(struct B307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B307,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B307,e) == 0, "");
#endif
_Static_assert(sizeof(B308) == 1, "");
_Static_assert(_Alignof(B308) == 1, "");
_Static_assert(sizeof(struct B308_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B308_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B308_extra_packed) == 1, "");
_Static_assert(sizeof(struct B308_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_size) == 3, "");
_Static_assert(_Alignof(struct B308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B308,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B308,e) == 0, "");
#endif
_Static_assert(sizeof(B309) == 1, "");
_Static_assert(_Alignof(B309) == 1, "");
_Static_assert(sizeof(struct B309_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B309_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B309_extra_packed) == 1, "");
_Static_assert(sizeof(struct B309_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_size) == 3, "");
_Static_assert(_Alignof(struct B309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B309,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B309,e) == 0, "");
#endif
_Static_assert(sizeof(B310) == 4, "");
_Static_assert(_Alignof(B310) == 1, "");
_Static_assert(sizeof(struct B310_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B310_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B310_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B310_extra_packed) == 1, "");
_Static_assert(sizeof(struct B310_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B310_extra_size) == 6, "");
_Static_assert(_Alignof(struct B310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B310,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B310,e) == 0, "");
#endif
_Static_assert(sizeof(B311) == 4, "");
_Static_assert(_Alignof(B311) == 1, "");
_Static_assert(sizeof(struct B311_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B311_extra_packed) == 1, "");
_Static_assert(sizeof(struct B311_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_size) == 6, "");
_Static_assert(_Alignof(struct B311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B311,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B311,e) == 0, "");
#endif
_Static_assert(sizeof(B312) == 4, "");
_Static_assert(_Alignof(B312) == 1, "");
_Static_assert(sizeof(struct B312_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B312_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B312_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B312_extra_packed) == 1, "");
_Static_assert(sizeof(struct B312_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B312_extra_size) == 6, "");
_Static_assert(_Alignof(struct B312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B312,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B312,e) == 0, "");
#endif
_Static_assert(sizeof(B313) == 4, "");
_Static_assert(_Alignof(B313) == 1, "");
_Static_assert(sizeof(struct B313_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B313_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B313_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B313_extra_packed) == 1, "");
_Static_assert(sizeof(struct B313_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B313_extra_size) == 6, "");
_Static_assert(_Alignof(struct B313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B313,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B313,e) == 0, "");
#endif
_Static_assert(sizeof(B314) == 4, "");
_Static_assert(_Alignof(B314) == 1, "");
_Static_assert(sizeof(struct B314_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B314_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B314_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B314_extra_packed) == 1, "");
_Static_assert(sizeof(struct B314_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B314_extra_size) == 6, "");
_Static_assert(_Alignof(struct B314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B314,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B314,e) == 0, "");
#endif
_Static_assert(sizeof(B315) == 4, "");
_Static_assert(_Alignof(B315) == 1, "");
_Static_assert(sizeof(struct B315_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B315_extra_packed) == 1, "");
_Static_assert(sizeof(struct B315_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_size) == 6, "");
_Static_assert(_Alignof(struct B315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B315,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B315,e) == 0, "");
#endif
_Static_assert(sizeof(B316) == 4, "");
_Static_assert(_Alignof(B316) == 1, "");
_Static_assert(sizeof(struct B316_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B316_extra_packed) == 1, "");
_Static_assert(sizeof(struct B316_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_size) == 6, "");
_Static_assert(_Alignof(struct B316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B316,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B316,e) == 0, "");
#endif
_Static_assert(sizeof(B317) == 4, "");
_Static_assert(_Alignof(B317) == 1, "");
_Static_assert(sizeof(struct B317_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B317_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B317_extra_packed) == 1, "");
_Static_assert(sizeof(struct B317_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_size) == 6, "");
_Static_assert(_Alignof(struct B317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B317,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B317,e) == 0, "");
#endif
_Static_assert(sizeof(B318) == 4, "");
_Static_assert(_Alignof(B318) == 1, "");
_Static_assert(sizeof(struct B318_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B318_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B318_extra_packed) == 1, "");
_Static_assert(sizeof(struct B318_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_size) == 6, "");
_Static_assert(_Alignof(struct B318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B318,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B318,e) == 0, "");
#endif
_Static_assert(sizeof(B319) == 4, "");
_Static_assert(_Alignof(B319) == 1, "");
_Static_assert(sizeof(struct B319_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B319_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B319_extra_packed) == 1, "");
_Static_assert(sizeof(struct B319_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_size) == 6, "");
_Static_assert(_Alignof(struct B319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B319,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B319,e) == 0, "");
#endif
_Static_assert(sizeof(B410) == 4, "");
_Static_assert(_Alignof(B410) == 2, "");
_Static_assert(sizeof(struct B410_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B410_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B410_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B410_extra_packed) == 1, "");
_Static_assert(sizeof(struct B410_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B410_extra_size) == 6, "");
_Static_assert(_Alignof(struct B410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B410,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B410,e) == 0, "");
#endif
_Static_assert(sizeof(B411) == 4, "");
_Static_assert(_Alignof(B411) == 1, "");
_Static_assert(sizeof(struct B411_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B411_extra_packed) == 1, "");
_Static_assert(sizeof(struct B411_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_size) == 6, "");
_Static_assert(_Alignof(struct B411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B411,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B411,e) == 0, "");
#endif
_Static_assert(sizeof(B412) == 4, "");
_Static_assert(_Alignof(B412) == 2, "");
_Static_assert(sizeof(struct B412_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B412_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B412_extra_packed) == 1, "");
_Static_assert(sizeof(struct B412_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B412_extra_size) == 6, "");
_Static_assert(_Alignof(struct B412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B412,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B412,e) == 0, "");
#endif
_Static_assert(sizeof(B413) == 4, "");
_Static_assert(_Alignof(B413) == 4, "");
_Static_assert(sizeof(struct B413_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B413_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B413_extra_packed) == 1, "");
_Static_assert(sizeof(struct B413_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B413_extra_size) == 6, "");
_Static_assert(_Alignof(struct B413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B413,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B413,e) == 0, "");
#endif
_Static_assert(sizeof(B414) == 4, "");
_Static_assert(_Alignof(B414) == 4, "");
_Static_assert(sizeof(struct B414_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B414_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B414_extra_packed) == 1, "");
_Static_assert(sizeof(struct B414_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B414_extra_size) == 6, "");
_Static_assert(_Alignof(struct B414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B414,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B414,e) == 0, "");
#endif
_Static_assert(sizeof(B415) == 4, "");
_Static_assert(_Alignof(B415) == 2, "");
_Static_assert(sizeof(struct B415_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B415_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B415_extra_packed) == 1, "");
_Static_assert(sizeof(struct B415_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B415_extra_size) == 6, "");
_Static_assert(_Alignof(struct B415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B415,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B415,e) == 0, "");
#endif
_Static_assert(sizeof(B416) == 4, "");
_Static_assert(_Alignof(B416) == 1, "");
_Static_assert(sizeof(struct B416_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B416_extra_packed) == 1, "");
_Static_assert(sizeof(struct B416_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_size) == 6, "");
_Static_assert(_Alignof(struct B416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B416,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B416,e) == 0, "");
#endif
_Static_assert(sizeof(B417) == 4, "");
_Static_assert(_Alignof(B417) == 2, "");
_Static_assert(sizeof(struct B417_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B417_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B417_extra_packed) == 1, "");
_Static_assert(sizeof(struct B417_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B417_extra_size) == 6, "");
_Static_assert(_Alignof(struct B417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B417,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B417,e) == 0, "");
#endif
_Static_assert(sizeof(B418) == 4, "");
_Static_assert(_Alignof(B418) == 4, "");
_Static_assert(sizeof(struct B418_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B418_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B418_extra_packed) == 1, "");
_Static_assert(sizeof(struct B418_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B418_extra_size) == 6, "");
_Static_assert(_Alignof(struct B418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B418,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B418,e) == 0, "");
#endif
_Static_assert(sizeof(B419) == 4, "");
_Static_assert(_Alignof(B419) == 4, "");
_Static_assert(sizeof(struct B419_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B419_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B419_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B419_extra_packed) == 1, "");
_Static_assert(sizeof(struct B419_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B419_extra_size) == 6, "");
_Static_assert(_Alignof(struct B419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B419,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B419,e) == 0, "");
#endif
_Static_assert(sizeof(B510) == 4, "");
_Static_assert(_Alignof(B510) == 1, "");
_Static_assert(sizeof(struct B510_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B510_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B510_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B510_extra_packed) == 1, "");
_Static_assert(sizeof(struct B510_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B510_extra_size) == 6, "");
_Static_assert(_Alignof(struct B510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B510,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B510,e) == 0, "");
#endif
_Static_assert(sizeof(B511) == 4, "");
_Static_assert(_Alignof(B511) == 1, "");
_Static_assert(sizeof(struct B511_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B511_extra_packed) == 1, "");
_Static_assert(sizeof(struct B511_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_size) == 6, "");
_Static_assert(_Alignof(struct B511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B511,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B511,e) == 0, "");
#endif
_Static_assert(sizeof(B512) == 4, "");
_Static_assert(_Alignof(B512) == 1, "");
_Static_assert(sizeof(struct B512_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B512_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B512_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B512_extra_packed) == 1, "");
_Static_assert(sizeof(struct B512_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B512_extra_size) == 6, "");
_Static_assert(_Alignof(struct B512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B512,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B512,e) == 0, "");
#endif
_Static_assert(sizeof(B513) == 4, "");
_Static_assert(_Alignof(B513) == 1, "");
_Static_assert(sizeof(struct B513_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B513_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B513_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B513_extra_packed) == 1, "");
_Static_assert(sizeof(struct B513_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B513_extra_size) == 6, "");
_Static_assert(_Alignof(struct B513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B513,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B513,e) == 0, "");
#endif
_Static_assert(sizeof(B514) == 4, "");
_Static_assert(_Alignof(B514) == 1, "");
_Static_assert(sizeof(struct B514_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B514_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B514_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B514_extra_packed) == 1, "");
_Static_assert(sizeof(struct B514_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B514_extra_size) == 6, "");
_Static_assert(_Alignof(struct B514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B514,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B514,e) == 0, "");
#endif
_Static_assert(sizeof(B515) == 4, "");
_Static_assert(_Alignof(B515) == 1, "");
_Static_assert(sizeof(struct B515_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B515_extra_packed) == 1, "");
_Static_assert(sizeof(struct B515_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_size) == 6, "");
_Static_assert(_Alignof(struct B515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B515,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B515,e) == 0, "");
#endif
_Static_assert(sizeof(B516) == 4, "");
_Static_assert(_Alignof(B516) == 1, "");
_Static_assert(sizeof(struct B516_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B516_extra_packed) == 1, "");
_Static_assert(sizeof(struct B516_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_size) == 6, "");
_Static_assert(_Alignof(struct B516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B516,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B516,e) == 0, "");
#endif
_Static_assert(sizeof(B517) == 4, "");
_Static_assert(_Alignof(B517) == 1, "");
_Static_assert(sizeof(struct B517_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B517_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B517_extra_packed) == 1, "");
_Static_assert(sizeof(struct B517_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_size) == 6, "");
_Static_assert(_Alignof(struct B517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B517,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B517,e) == 0, "");
#endif
_Static_assert(sizeof(B518) == 4, "");
_Static_assert(_Alignof(B518) == 1, "");
_Static_assert(sizeof(struct B518_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B518_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B518_extra_packed) == 1, "");
_Static_assert(sizeof(struct B518_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_size) == 6, "");
_Static_assert(_Alignof(struct B518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B518,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B518,e) == 0, "");
#endif
_Static_assert(sizeof(B519) == 4, "");
_Static_assert(_Alignof(B519) == 1, "");
_Static_assert(sizeof(struct B519_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B519_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B519_extra_packed) == 1, "");
_Static_assert(sizeof(struct B519_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_size) == 6, "");
_Static_assert(_Alignof(struct B519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B519,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B519,e) == 0, "");
#endif
// MAPPING|SIX|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A000) == 4, "");
_Static_assert(_Alignof(A000) == 2, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 6, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A000,e) == 17, "");
#endif
_Static_assert(sizeof(A001) == 2, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 4, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A001,e) == 9, "");
#endif
_Static_assert(sizeof(A002) == 4, "");
_Static_assert(_Alignof(A002) == 2, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A002_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 6, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A002,e) == 17, "");
#endif
_Static_assert(sizeof(A003) == 8, "");
_Static_assert(_Alignof(A003) == 4, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A003_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 10, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A003,e) == 33, "");
#endif
_Static_assert(sizeof(A004) == 8, "");
_Static_assert(_Alignof(A004) == 4, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A004_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 10, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A004,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A004,e) == 33, "");
#endif
_Static_assert(sizeof(A005) == 4, "");
_Static_assert(_Alignof(A005) == 2, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A005_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 6, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A005,e) == 17, "");
#endif
_Static_assert(sizeof(A006) == 2, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 4, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A006,e) == 9, "");
#endif
_Static_assert(sizeof(A007) == 4, "");
_Static_assert(_Alignof(A007) == 2, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A007_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 6, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A007,e) == 17, "");
#endif
_Static_assert(sizeof(A008) == 8, "");
_Static_assert(_Alignof(A008) == 4, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A008_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 10, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A008,e) == 33, "");
#endif
_Static_assert(sizeof(A009) == 8, "");
_Static_assert(_Alignof(A009) == 4, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A009_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 10, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A009,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A009,e) == 33, "");
#endif
_Static_assert(sizeof(A010) == 4, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 6, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A010,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A010,e) == 24, "");
#endif
_Static_assert(sizeof(A011) == 3, "");
_Static_assert(_Alignof(A011) == 1, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 5, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A011,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A011,e) == 16, "");
#endif
_Static_assert(sizeof(A012) == 4, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 6, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A012,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A012,e) == 24, "");
#endif
_Static_assert(sizeof(A013) == 8, "");
_Static_assert(_Alignof(A013) == 4, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A013_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 10, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A013,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A013,e) == 40, "");
#endif
_Static_assert(sizeof(A014) == 8, "");
_Static_assert(_Alignof(A014) == 4, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A014_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 10, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A014,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A014,e) == 40, "");
#endif
_Static_assert(sizeof(A015) == 4, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 6, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A015,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A015,e) == 24, "");
#endif
_Static_assert(sizeof(A016) == 3, "");
_Static_assert(_Alignof(A016) == 1, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 5, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A016,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A016,e) == 16, "");
#endif
_Static_assert(sizeof(A017) == 4, "");
_Static_assert(_Alignof(A017) == 2, "");
_Static_assert(sizeof(struct A017_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A017_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A017_extra_packed) == 1, "");
_Static_assert(sizeof(struct A017_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A017_extra_size) == 6, "");
_Static_assert(_Alignof(struct A017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A017,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A017,e) == 24, "");
#endif
_Static_assert(sizeof(A018) == 8, "");
_Static_assert(_Alignof(A018) == 4, "");
_Static_assert(sizeof(struct A018_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A018_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A018_extra_packed) == 1, "");
_Static_assert(sizeof(struct A018_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A018_extra_size) == 10, "");
_Static_assert(_Alignof(struct A018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A018,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A018,e) == 40, "");
#endif
_Static_assert(sizeof(A019) == 8, "");
_Static_assert(_Alignof(A019) == 4, "");
_Static_assert(sizeof(struct A019_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A019_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A019_extra_packed) == 1, "");
_Static_assert(sizeof(struct A019_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A019_extra_size) == 10, "");
_Static_assert(_Alignof(struct A019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A019,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A019,e) == 40, "");
#endif
_Static_assert(sizeof(A100) == 4, "");
_Static_assert(_Alignof(A100) == 2, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 6, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A100,e) == 17, "");
#endif
_Static_assert(sizeof(A101) == 2, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 4, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A101,e) == 9, "");
#endif
_Static_assert(sizeof(A102) == 4, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 6, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A102,e) == 17, "");
#endif
_Static_assert(sizeof(A103) == 8, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 10, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A103,e) == 33, "");
#endif
_Static_assert(sizeof(A104) == 8, "");
_Static_assert(_Alignof(A104) == 4, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A104_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 10, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A104,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A104,e) == 33, "");
#endif
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A105,e) == 17, "");
#endif
_Static_assert(sizeof(A106) == 2, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 4, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A106,e) == 9, "");
#endif
_Static_assert(sizeof(A107) == 4, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 6, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A107,e) == 17, "");
#endif
_Static_assert(sizeof(A108) == 8, "");
_Static_assert(_Alignof(A108) == 4, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A108_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 10, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A108,e) == 33, "");
#endif
_Static_assert(sizeof(A109) == 8, "");
_Static_assert(_Alignof(A109) == 4, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A109_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 10, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A109,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A109,e) == 33, "");
#endif
_Static_assert(sizeof(A110) == 6, "");
_Static_assert(_Alignof(A110) == 2, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A110_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 8, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A110,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A110,e) == 47, "");
#endif
_Static_assert(sizeof(A111) == 5, "");
_Static_assert(_Alignof(A111) == 1, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 7, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A111,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A111,e) == 39, "");
#endif
_Static_assert(sizeof(A112) == 6, "");
_Static_assert(_Alignof(A112) == 2, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A112_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 8, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A112,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A112,e) == 47, "");
#endif
_Static_assert(sizeof(A113) == 8, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 10, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A113,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A113,e) == 63, "");
#endif
_Static_assert(sizeof(A114) == 8, "");
_Static_assert(_Alignof(A114) == 4, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A114_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 10, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A114,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A114,e) == 63, "");
#endif
_Static_assert(sizeof(A115) == 6, "");
_Static_assert(_Alignof(A115) == 2, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A115_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 8, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A115,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A115,e) == 47, "");
#endif
_Static_assert(sizeof(A116) == 5, "");
_Static_assert(_Alignof(A116) == 1, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 7, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A116,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A116,e) == 39, "");
#endif
_Static_assert(sizeof(A117) == 6, "");
_Static_assert(_Alignof(A117) == 2, "");
_Static_assert(sizeof(struct A117_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A117_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A117_extra_packed) == 1, "");
_Static_assert(sizeof(struct A117_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A117_extra_size) == 8, "");
_Static_assert(_Alignof(struct A117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A117,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A117,e) == 47, "");
#endif
_Static_assert(sizeof(A118) == 8, "");
_Static_assert(_Alignof(A118) == 4, "");
_Static_assert(sizeof(struct A118_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A118_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A118_extra_packed) == 1, "");
_Static_assert(sizeof(struct A118_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A118_extra_size) == 10, "");
_Static_assert(_Alignof(struct A118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A118,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A118,e) == 63, "");
#endif
_Static_assert(sizeof(A119) == 8, "");
_Static_assert(_Alignof(A119) == 4, "");
_Static_assert(sizeof(struct A119_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A119_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A119_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A119_extra_packed) == 1, "");
_Static_assert(sizeof(struct A119_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A119_extra_size) == 10, "");
_Static_assert(_Alignof(struct A119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A119,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A119,e) == 63, "");
#endif
_Static_assert(sizeof(A200) == 1, "");
_Static_assert(_Alignof(A200) == 1, "");
_Static_assert(sizeof(struct A200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A200_extra_packed) == 1, "");
_Static_assert(sizeof(struct A200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_size) == 3, "");
_Static_assert(_Alignof(struct A200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A200,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A200,e) == 2, "");
#endif
_Static_assert(sizeof(A201) == 1, "");
_Static_assert(_Alignof(A201) == 1, "");
_Static_assert(sizeof(struct A201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A201_extra_packed) == 1, "");
_Static_assert(sizeof(struct A201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_size) == 3, "");
_Static_assert(_Alignof(struct A201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A201,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A201,e) == 2, "");
#endif
_Static_assert(sizeof(A202) == 1, "");
_Static_assert(_Alignof(A202) == 1, "");
_Static_assert(sizeof(struct A202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A202_extra_packed) == 1, "");
_Static_assert(sizeof(struct A202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_size) == 3, "");
_Static_assert(_Alignof(struct A202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A202,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A202,e) == 2, "");
#endif
_Static_assert(sizeof(A203) == 1, "");
_Static_assert(_Alignof(A203) == 1, "");
_Static_assert(sizeof(struct A203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A203_extra_packed) == 1, "");
_Static_assert(sizeof(struct A203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_size) == 3, "");
_Static_assert(_Alignof(struct A203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A203,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A203,e) == 2, "");
#endif
_Static_assert(sizeof(A204) == 1, "");
_Static_assert(_Alignof(A204) == 1, "");
_Static_assert(sizeof(struct A204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A204_extra_packed) == 1, "");
_Static_assert(sizeof(struct A204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_size) == 3, "");
_Static_assert(_Alignof(struct A204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A204,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A204,e) == 2, "");
#endif
_Static_assert(sizeof(A205) == 1, "");
_Static_assert(_Alignof(A205) == 1, "");
_Static_assert(sizeof(struct A205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A205_extra_packed) == 1, "");
_Static_assert(sizeof(struct A205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_size) == 3, "");
_Static_assert(_Alignof(struct A205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A205,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A205,e) == 2, "");
#endif
_Static_assert(sizeof(A206) == 1, "");
_Static_assert(_Alignof(A206) == 1, "");
_Static_assert(sizeof(struct A206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A206_extra_packed) == 1, "");
_Static_assert(sizeof(struct A206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_size) == 3, "");
_Static_assert(_Alignof(struct A206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A206,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A206,e) == 2, "");
#endif
_Static_assert(sizeof(A207) == 1, "");
_Static_assert(_Alignof(A207) == 1, "");
_Static_assert(sizeof(struct A207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A207_extra_packed) == 1, "");
_Static_assert(sizeof(struct A207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_size) == 3, "");
_Static_assert(_Alignof(struct A207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A207,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A207,e) == 2, "");
#endif
_Static_assert(sizeof(A208) == 1, "");
_Static_assert(_Alignof(A208) == 1, "");
_Static_assert(sizeof(struct A208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A208_extra_packed) == 1, "");
_Static_assert(sizeof(struct A208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_size) == 3, "");
_Static_assert(_Alignof(struct A208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A208,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A208,e) == 2, "");
#endif
_Static_assert(sizeof(A209) == 1, "");
_Static_assert(_Alignof(A209) == 1, "");
_Static_assert(sizeof(struct A209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A209_extra_packed) == 1, "");
_Static_assert(sizeof(struct A209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_size) == 3, "");
_Static_assert(_Alignof(struct A209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A209,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A209,e) == 2, "");
#endif
_Static_assert(sizeof(A210) == 2, "");
_Static_assert(_Alignof(A210) == 1, "");
_Static_assert(sizeof(struct A210_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A210_extra_packed) == 1, "");
_Static_assert(sizeof(struct A210_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_size) == 4, "");
_Static_assert(_Alignof(struct A210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A210,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A210,e) == 9, "");
#endif
_Static_assert(sizeof(A211) == 2, "");
_Static_assert(_Alignof(A211) == 1, "");
_Static_assert(sizeof(struct A211_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A211_extra_packed) == 1, "");
_Static_assert(sizeof(struct A211_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_size) == 4, "");
_Static_assert(_Alignof(struct A211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A211,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A211,e) == 9, "");
#endif
_Static_assert(sizeof(A212) == 2, "");
_Static_assert(_Alignof(A212) == 1, "");
_Static_assert(sizeof(struct A212_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A212_extra_packed) == 1, "");
_Static_assert(sizeof(struct A212_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_size) == 4, "");
_Static_assert(_Alignof(struct A212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A212,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A212,e) == 9, "");
#endif
_Static_assert(sizeof(A213) == 2, "");
_Static_assert(_Alignof(A213) == 1, "");
_Static_assert(sizeof(struct A213_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A213_extra_packed) == 1, "");
_Static_assert(sizeof(struct A213_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_size) == 4, "");
_Static_assert(_Alignof(struct A213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A213,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A213,e) == 9, "");
#endif
_Static_assert(sizeof(A214) == 2, "");
_Static_assert(_Alignof(A214) == 1, "");
_Static_assert(sizeof(struct A214_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A214_extra_packed) == 1, "");
_Static_assert(sizeof(struct A214_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_size) == 4, "");
_Static_assert(_Alignof(struct A214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A214,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A214,e) == 9, "");
#endif
_Static_assert(sizeof(A215) == 2, "");
_Static_assert(_Alignof(A215) == 1, "");
_Static_assert(sizeof(struct A215_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A215_extra_packed) == 1, "");
_Static_assert(sizeof(struct A215_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_size) == 4, "");
_Static_assert(_Alignof(struct A215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A215,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A215,e) == 9, "");
#endif
_Static_assert(sizeof(A216) == 2, "");
_Static_assert(_Alignof(A216) == 1, "");
_Static_assert(sizeof(struct A216_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A216_extra_packed) == 1, "");
_Static_assert(sizeof(struct A216_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_size) == 4, "");
_Static_assert(_Alignof(struct A216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A216,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A216,e) == 9, "");
#endif
_Static_assert(sizeof(A217) == 2, "");
_Static_assert(_Alignof(A217) == 1, "");
_Static_assert(sizeof(struct A217_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A217_extra_packed) == 1, "");
_Static_assert(sizeof(struct A217_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_size) == 4, "");
_Static_assert(_Alignof(struct A217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A217,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A217,e) == 9, "");
#endif
_Static_assert(sizeof(A218) == 2, "");
_Static_assert(_Alignof(A218) == 1, "");
_Static_assert(sizeof(struct A218_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A218_extra_packed) == 1, "");
_Static_assert(sizeof(struct A218_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_size) == 4, "");
_Static_assert(_Alignof(struct A218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A218,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A218,e) == 9, "");
#endif
_Static_assert(sizeof(A219) == 2, "");
_Static_assert(_Alignof(A219) == 1, "");
_Static_assert(sizeof(struct A219_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A219_extra_packed) == 1, "");
_Static_assert(sizeof(struct A219_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_size) == 4, "");
_Static_assert(_Alignof(struct A219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A219,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A219,e) == 9, "");
#endif
_Static_assert(sizeof(A300) == 1, "");
_Static_assert(_Alignof(A300) == 1, "");
_Static_assert(sizeof(struct A300_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A300_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A300_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A300_extra_packed) == 1, "");
_Static_assert(sizeof(struct A300_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A300_extra_size) == 3, "");
_Static_assert(_Alignof(struct A300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A300,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A300,e) == 3, "");
#endif
_Static_assert(sizeof(A301) == 1, "");
_Static_assert(_Alignof(A301) == 1, "");
_Static_assert(sizeof(struct A301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A301_extra_packed) == 1, "");
_Static_assert(sizeof(struct A301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_size) == 3, "");
_Static_assert(_Alignof(struct A301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A301,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A301,e) == 3, "");
#endif
_Static_assert(sizeof(A302) == 1, "");
_Static_assert(_Alignof(A302) == 1, "");
_Static_assert(sizeof(struct A302_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A302_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A302_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A302_extra_packed) == 1, "");
_Static_assert(sizeof(struct A302_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A302_extra_size) == 3, "");
_Static_assert(_Alignof(struct A302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A302,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A302,e) == 3, "");
#endif
_Static_assert(sizeof(A303) == 1, "");
_Static_assert(_Alignof(A303) == 1, "");
_Static_assert(sizeof(struct A303_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A303_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A303_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A303_extra_packed) == 1, "");
_Static_assert(sizeof(struct A303_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A303_extra_size) == 3, "");
_Static_assert(_Alignof(struct A303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A303,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A303,e) == 3, "");
#endif
_Static_assert(sizeof(A304) == 1, "");
_Static_assert(_Alignof(A304) == 1, "");
_Static_assert(sizeof(struct A304_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A304_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A304_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A304_extra_packed) == 1, "");
_Static_assert(sizeof(struct A304_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A304_extra_size) == 3, "");
_Static_assert(_Alignof(struct A304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A304,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A304,e) == 3, "");
#endif
_Static_assert(sizeof(A305) == 1, "");
_Static_assert(_Alignof(A305) == 1, "");
_Static_assert(sizeof(struct A305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A305_extra_packed) == 1, "");
_Static_assert(sizeof(struct A305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_size) == 3, "");
_Static_assert(_Alignof(struct A305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A305,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A305,e) == 3, "");
#endif
_Static_assert(sizeof(A306) == 1, "");
_Static_assert(_Alignof(A306) == 1, "");
_Static_assert(sizeof(struct A306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A306_extra_packed) == 1, "");
_Static_assert(sizeof(struct A306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_size) == 3, "");
_Static_assert(_Alignof(struct A306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A306,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A306,e) == 3, "");
#endif
_Static_assert(sizeof(A307) == 1, "");
_Static_assert(_Alignof(A307) == 1, "");
_Static_assert(sizeof(struct A307_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A307_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A307_extra_packed) == 1, "");
_Static_assert(sizeof(struct A307_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_size) == 3, "");
_Static_assert(_Alignof(struct A307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A307,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A307,e) == 3, "");
#endif
_Static_assert(sizeof(A308) == 1, "");
_Static_assert(_Alignof(A308) == 1, "");
_Static_assert(sizeof(struct A308_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A308_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A308_extra_packed) == 1, "");
_Static_assert(sizeof(struct A308_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_size) == 3, "");
_Static_assert(_Alignof(struct A308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A308,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A308,e) == 3, "");
#endif
_Static_assert(sizeof(A309) == 1, "");
_Static_assert(_Alignof(A309) == 1, "");
_Static_assert(sizeof(struct A309_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A309_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A309_extra_packed) == 1, "");
_Static_assert(sizeof(struct A309_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_size) == 3, "");
_Static_assert(_Alignof(struct A309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A309,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A309,e) == 3, "");
#endif
_Static_assert(sizeof(A310) == 5, "");
_Static_assert(_Alignof(A310) == 1, "");
_Static_assert(sizeof(struct A310_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A310_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A310_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A310_extra_packed) == 1, "");
_Static_assert(sizeof(struct A310_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A310_extra_size) == 7, "");
_Static_assert(_Alignof(struct A310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A310,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A310,e) == 33, "");
#endif
_Static_assert(sizeof(A311) == 5, "");
_Static_assert(_Alignof(A311) == 1, "");
_Static_assert(sizeof(struct A311_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A311_extra_packed) == 1, "");
_Static_assert(sizeof(struct A311_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_size) == 7, "");
_Static_assert(_Alignof(struct A311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A311,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A311,e) == 33, "");
#endif
_Static_assert(sizeof(A312) == 5, "");
_Static_assert(_Alignof(A312) == 1, "");
_Static_assert(sizeof(struct A312_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A312_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A312_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A312_extra_packed) == 1, "");
_Static_assert(sizeof(struct A312_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A312_extra_size) == 7, "");
_Static_assert(_Alignof(struct A312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A312,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A312,e) == 33, "");
#endif
_Static_assert(sizeof(A313) == 5, "");
_Static_assert(_Alignof(A313) == 1, "");
_Static_assert(sizeof(struct A313_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A313_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A313_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A313_extra_packed) == 1, "");
_Static_assert(sizeof(struct A313_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A313_extra_size) == 7, "");
_Static_assert(_Alignof(struct A313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A313,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A313,e) == 33, "");
#endif
_Static_assert(sizeof(A314) == 5, "");
_Static_assert(_Alignof(A314) == 1, "");
_Static_assert(sizeof(struct A314_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A314_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A314_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A314_extra_packed) == 1, "");
_Static_assert(sizeof(struct A314_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A314_extra_size) == 7, "");
_Static_assert(_Alignof(struct A314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A314,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A314,e) == 33, "");
#endif
_Static_assert(sizeof(A315) == 5, "");
_Static_assert(_Alignof(A315) == 1, "");
_Static_assert(sizeof(struct A315_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A315_extra_packed) == 1, "");
_Static_assert(sizeof(struct A315_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_size) == 7, "");
_Static_assert(_Alignof(struct A315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A315,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A315,e) == 33, "");
#endif
_Static_assert(sizeof(A316) == 5, "");
_Static_assert(_Alignof(A316) == 1, "");
_Static_assert(sizeof(struct A316_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A316_extra_packed) == 1, "");
_Static_assert(sizeof(struct A316_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_size) == 7, "");
_Static_assert(_Alignof(struct A316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A316,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A316,e) == 33, "");
#endif
_Static_assert(sizeof(A317) == 5, "");
_Static_assert(_Alignof(A317) == 1, "");
_Static_assert(sizeof(struct A317_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A317_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A317_extra_packed) == 1, "");
_Static_assert(sizeof(struct A317_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_size) == 7, "");
_Static_assert(_Alignof(struct A317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A317,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A317,e) == 33, "");
#endif
_Static_assert(sizeof(A318) == 5, "");
_Static_assert(_Alignof(A318) == 1, "");
_Static_assert(sizeof(struct A318_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A318_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A318_extra_packed) == 1, "");
_Static_assert(sizeof(struct A318_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_size) == 7, "");
_Static_assert(_Alignof(struct A318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A318,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A318,e) == 33, "");
#endif
_Static_assert(sizeof(A319) == 5, "");
_Static_assert(_Alignof(A319) == 1, "");
_Static_assert(sizeof(struct A319_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A319_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A319_extra_packed) == 1, "");
_Static_assert(sizeof(struct A319_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_size) == 7, "");
_Static_assert(_Alignof(struct A319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A319,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A319,e) == 33, "");
#endif
_Static_assert(sizeof(A410) == 6, "");
_Static_assert(_Alignof(A410) == 2, "");
_Static_assert(sizeof(struct A410_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A410_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A410_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A410_extra_packed) == 1, "");
_Static_assert(sizeof(struct A410_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A410_extra_size) == 8, "");
_Static_assert(_Alignof(struct A410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A410,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A410,e) == 46, "");
#endif
_Static_assert(sizeof(A411) == 5, "");
_Static_assert(_Alignof(A411) == 1, "");
_Static_assert(sizeof(struct A411_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A411_extra_packed) == 1, "");
_Static_assert(sizeof(struct A411_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_size) == 7, "");
_Static_assert(_Alignof(struct A411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A411,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A411,e) == 38, "");
#endif
_Static_assert(sizeof(A412) == 6, "");
_Static_assert(_Alignof(A412) == 2, "");
_Static_assert(sizeof(struct A412_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A412_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A412_extra_packed) == 1, "");
_Static_assert(sizeof(struct A412_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A412_extra_size) == 8, "");
_Static_assert(_Alignof(struct A412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A412,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A412,e) == 46, "");
#endif
_Static_assert(sizeof(A413) == 8, "");
_Static_assert(_Alignof(A413) == 4, "");
_Static_assert(sizeof(struct A413_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A413_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A413_extra_packed) == 1, "");
_Static_assert(sizeof(struct A413_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A413_extra_size) == 10, "");
_Static_assert(_Alignof(struct A413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A413,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A413,e) == 62, "");
#endif
_Static_assert(sizeof(A414) == 8, "");
_Static_assert(_Alignof(A414) == 4, "");
_Static_assert(sizeof(struct A414_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A414_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A414_extra_packed) == 1, "");
_Static_assert(sizeof(struct A414_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A414_extra_size) == 10, "");
_Static_assert(_Alignof(struct A414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A414,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A414,e) == 62, "");
#endif
_Static_assert(sizeof(A415) == 6, "");
_Static_assert(_Alignof(A415) == 2, "");
_Static_assert(sizeof(struct A415_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A415_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A415_extra_packed) == 1, "");
_Static_assert(sizeof(struct A415_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A415_extra_size) == 8, "");
_Static_assert(_Alignof(struct A415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A415,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A415,e) == 46, "");
#endif
_Static_assert(sizeof(A416) == 5, "");
_Static_assert(_Alignof(A416) == 1, "");
_Static_assert(sizeof(struct A416_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A416_extra_packed) == 1, "");
_Static_assert(sizeof(struct A416_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_size) == 7, "");
_Static_assert(_Alignof(struct A416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A416,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A416,e) == 38, "");
#endif
_Static_assert(sizeof(A417) == 6, "");
_Static_assert(_Alignof(A417) == 2, "");
_Static_assert(sizeof(struct A417_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A417_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A417_extra_packed) == 1, "");
_Static_assert(sizeof(struct A417_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A417_extra_size) == 8, "");
_Static_assert(_Alignof(struct A417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A417,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A417,e) == 46, "");
#endif
_Static_assert(sizeof(A418) == 8, "");
_Static_assert(_Alignof(A418) == 4, "");
_Static_assert(sizeof(struct A418_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A418_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A418_extra_packed) == 1, "");
_Static_assert(sizeof(struct A418_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A418_extra_size) == 10, "");
_Static_assert(_Alignof(struct A418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A418,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A418,e) == 62, "");
#endif
_Static_assert(sizeof(A419) == 8, "");
_Static_assert(_Alignof(A419) == 4, "");
_Static_assert(sizeof(struct A419_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A419_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A419_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A419_extra_packed) == 1, "");
_Static_assert(sizeof(struct A419_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A419_extra_size) == 10, "");
_Static_assert(_Alignof(struct A419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A419,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A419,e) == 62, "");
#endif
_Static_assert(sizeof(A510) == 5, "");
_Static_assert(_Alignof(A510) == 1, "");
_Static_assert(sizeof(struct A510_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A510_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A510_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A510_extra_packed) == 1, "");
_Static_assert(sizeof(struct A510_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A510_extra_size) == 7, "");
_Static_assert(_Alignof(struct A510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A510,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A510,e) == 32, "");
#endif
_Static_assert(sizeof(A511) == 5, "");
_Static_assert(_Alignof(A511) == 1, "");
_Static_assert(sizeof(struct A511_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A511_extra_packed) == 1, "");
_Static_assert(sizeof(struct A511_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_size) == 7, "");
_Static_assert(_Alignof(struct A511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A511,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A511,e) == 32, "");
#endif
_Static_assert(sizeof(A512) == 5, "");
_Static_assert(_Alignof(A512) == 1, "");
_Static_assert(sizeof(struct A512_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A512_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A512_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A512_extra_packed) == 1, "");
_Static_assert(sizeof(struct A512_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A512_extra_size) == 7, "");
_Static_assert(_Alignof(struct A512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A512,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A512,e) == 32, "");
#endif
_Static_assert(sizeof(A513) == 5, "");
_Static_assert(_Alignof(A513) == 1, "");
_Static_assert(sizeof(struct A513_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A513_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A513_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A513_extra_packed) == 1, "");
_Static_assert(sizeof(struct A513_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A513_extra_size) == 7, "");
_Static_assert(_Alignof(struct A513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A513,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A513,e) == 32, "");
#endif
_Static_assert(sizeof(A514) == 5, "");
_Static_assert(_Alignof(A514) == 1, "");
_Static_assert(sizeof(struct A514_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A514_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A514_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A514_extra_packed) == 1, "");
_Static_assert(sizeof(struct A514_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A514_extra_size) == 7, "");
_Static_assert(_Alignof(struct A514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A514,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A514,e) == 32, "");
#endif
_Static_assert(sizeof(A515) == 5, "");
_Static_assert(_Alignof(A515) == 1, "");
_Static_assert(sizeof(struct A515_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A515_extra_packed) == 1, "");
_Static_assert(sizeof(struct A515_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_size) == 7, "");
_Static_assert(_Alignof(struct A515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A515,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A515,e) == 32, "");
#endif
_Static_assert(sizeof(A516) == 5, "");
_Static_assert(_Alignof(A516) == 1, "");
_Static_assert(sizeof(struct A516_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A516_extra_packed) == 1, "");
_Static_assert(sizeof(struct A516_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_size) == 7, "");
_Static_assert(_Alignof(struct A516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A516,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A516,e) == 32, "");
#endif
_Static_assert(sizeof(A517) == 5, "");
_Static_assert(_Alignof(A517) == 1, "");
_Static_assert(sizeof(struct A517_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A517_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A517_extra_packed) == 1, "");
_Static_assert(sizeof(struct A517_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_size) == 7, "");
_Static_assert(_Alignof(struct A517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A517,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A517,e) == 32, "");
#endif
_Static_assert(sizeof(A518) == 5, "");
_Static_assert(_Alignof(A518) == 1, "");
_Static_assert(sizeof(struct A518_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A518_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A518_extra_packed) == 1, "");
_Static_assert(sizeof(struct A518_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_size) == 7, "");
_Static_assert(_Alignof(struct A518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A518,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A518,e) == 32, "");
#endif
_Static_assert(sizeof(A519) == 5, "");
_Static_assert(_Alignof(A519) == 1, "");
_Static_assert(sizeof(struct A519_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A519_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A519_extra_packed) == 1, "");
_Static_assert(sizeof(struct A519_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_size) == 7, "");
_Static_assert(_Alignof(struct A519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A519,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A519,e) == 32, "");
#endif
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 2, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B000,e) == 0, "");
#endif
_Static_assert(sizeof(B001) == 1, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 3, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B001,e) == 0, "");
#endif
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 2, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B002,e) == 0, "");
#endif
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 4, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B003,e) == 0, "");
#endif
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 4, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B004,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B004,e) == 0, "");
#endif
_Static_assert(sizeof(B005) == 2, "");
_Static_assert(_Alignof(B005) == 2, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B005_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 4, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B005,e) == 0, "");
#endif
_Static_assert(sizeof(B006) == 1, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 3, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B006,e) == 0, "");
#endif
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 2, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B007,e) == 0, "");
#endif
_Static_assert(sizeof(B008) == 4, "");
_Static_assert(_Alignof(B008) == 4, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B008_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 6, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B008,e) == 0, "");
#endif
_Static_assert(sizeof(B009) == 4, "");
_Static_assert(_Alignof(B009) == 4, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B009_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 6, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B009,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B009,e) == 0, "");
#endif
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 2, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B010,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B010,e) == 0, "");
#endif
_Static_assert(sizeof(B011) == 1, "");
_Static_assert(_Alignof(B011) == 1, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 3, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B011,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B011,e) == 0, "");
#endif
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 2, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B012,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B012,e) == 0, "");
#endif
_Static_assert(sizeof(B013) == 4, "");
_Static_assert(_Alignof(B013) == 4, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B013_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 6, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B013,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B013,e) == 0, "");
#endif
_Static_assert(sizeof(B014) == 4, "");
_Static_assert(_Alignof(B014) == 4, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B014_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 6, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B014,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B014,e) == 0, "");
#endif
_Static_assert(sizeof(B015) == 2, "");
_Static_assert(_Alignof(B015) == 2, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 4, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B015,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B015,e) == 0, "");
#endif
_Static_assert(sizeof(B016) == 1, "");
_Static_assert(_Alignof(B016) == 1, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 3, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B016,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B016,e) == 0, "");
#endif
_Static_assert(sizeof(B017) == 2, "");
_Static_assert(_Alignof(B017) == 2, "");
_Static_assert(sizeof(struct B017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B017_extra_packed) == 1, "");
_Static_assert(sizeof(struct B017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B017_extra_size) == 4, "");
_Static_assert(_Alignof(struct B017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B017,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B017,e) == 0, "");
#endif
_Static_assert(sizeof(B018) == 4, "");
_Static_assert(_Alignof(B018) == 4, "");
_Static_assert(sizeof(struct B018_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B018_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B018_extra_packed) == 1, "");
_Static_assert(sizeof(struct B018_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B018_extra_size) == 6, "");
_Static_assert(_Alignof(struct B018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B018,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B018,e) == 0, "");
#endif
_Static_assert(sizeof(B019) == 4, "");
_Static_assert(_Alignof(B019) == 4, "");
_Static_assert(sizeof(struct B019_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B019_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B019_extra_packed) == 1, "");
_Static_assert(sizeof(struct B019_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B019_extra_size) == 6, "");
_Static_assert(_Alignof(struct B019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B019,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B019,e) == 0, "");
#endif
_Static_assert(sizeof(B100) == 2, "");
_Static_assert(_Alignof(B100) == 2, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B100_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 4, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B100,e) == 0, "");
#endif
_Static_assert(sizeof(B101) == 1, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 3, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B101,e) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B102,e) == 0, "");
#endif
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B103,e) == 0, "");
#endif
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 4, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B104,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B104,e) == 0, "");
#endif
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B105,e) == 0, "");
#endif
_Static_assert(sizeof(B106) == 1, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 3, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B106,e) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B107,e) == 0, "");
#endif
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 4, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B108,e) == 0, "");
#endif
_Static_assert(sizeof(B109) == 4, "");
_Static_assert(_Alignof(B109) == 4, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 6, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B109,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B109,e) == 0, "");
#endif
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 2, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B110,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B110,e) == 0, "");
#endif
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 1, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B111,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B111,e) == 0, "");
#endif
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 2, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B112,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B112,e) == 0, "");
#endif
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B113,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B113,e) == 0, "");
#endif
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 4, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B114,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B114,e) == 0, "");
#endif
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 2, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B115,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B115,e) == 0, "");
#endif
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 1, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B116,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B116,e) == 0, "");
#endif
_Static_assert(sizeof(B117) == 4, "");
_Static_assert(_Alignof(B117) == 2, "");
_Static_assert(sizeof(struct B117_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B117_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B117_extra_packed) == 1, "");
_Static_assert(sizeof(struct B117_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B117_extra_size) == 6, "");
_Static_assert(_Alignof(struct B117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B117,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B117,e) == 0, "");
#endif
_Static_assert(sizeof(B118) == 4, "");
_Static_assert(_Alignof(B118) == 4, "");
_Static_assert(sizeof(struct B118_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B118_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B118_extra_packed) == 1, "");
_Static_assert(sizeof(struct B118_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B118_extra_size) == 6, "");
_Static_assert(_Alignof(struct B118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B118,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B118,e) == 0, "");
#endif
_Static_assert(sizeof(B119) == 4, "");
_Static_assert(_Alignof(B119) == 4, "");
_Static_assert(sizeof(struct B119_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B119_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B119_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B119_extra_packed) == 1, "");
_Static_assert(sizeof(struct B119_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B119_extra_size) == 6, "");
_Static_assert(_Alignof(struct B119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B119,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B119,e) == 0, "");
#endif
_Static_assert(sizeof(B200) == 1, "");
_Static_assert(_Alignof(B200) == 1, "");
_Static_assert(sizeof(struct B200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B200_extra_packed) == 1, "");
_Static_assert(sizeof(struct B200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_size) == 3, "");
_Static_assert(_Alignof(struct B200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B200,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B200,e) == 0, "");
#endif
_Static_assert(sizeof(B201) == 1, "");
_Static_assert(_Alignof(B201) == 1, "");
_Static_assert(sizeof(struct B201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B201_extra_packed) == 1, "");
_Static_assert(sizeof(struct B201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_size) == 3, "");
_Static_assert(_Alignof(struct B201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B201,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B201,e) == 0, "");
#endif
_Static_assert(sizeof(B202) == 1, "");
_Static_assert(_Alignof(B202) == 1, "");
_Static_assert(sizeof(struct B202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B202_extra_packed) == 1, "");
_Static_assert(sizeof(struct B202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_size) == 3, "");
_Static_assert(_Alignof(struct B202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B202,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B202,e) == 0, "");
#endif
_Static_assert(sizeof(B203) == 1, "");
_Static_assert(_Alignof(B203) == 1, "");
_Static_assert(sizeof(struct B203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B203_extra_packed) == 1, "");
_Static_assert(sizeof(struct B203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_size) == 3, "");
_Static_assert(_Alignof(struct B203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B203,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B203,e) == 0, "");
#endif
_Static_assert(sizeof(B204) == 1, "");
_Static_assert(_Alignof(B204) == 1, "");
_Static_assert(sizeof(struct B204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B204_extra_packed) == 1, "");
_Static_assert(sizeof(struct B204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_size) == 3, "");
_Static_assert(_Alignof(struct B204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B204,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B204,e) == 0, "");
#endif
_Static_assert(sizeof(B205) == 1, "");
_Static_assert(_Alignof(B205) == 1, "");
_Static_assert(sizeof(struct B205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B205_extra_packed) == 1, "");
_Static_assert(sizeof(struct B205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_size) == 3, "");
_Static_assert(_Alignof(struct B205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B205,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B205,e) == 0, "");
#endif
_Static_assert(sizeof(B206) == 1, "");
_Static_assert(_Alignof(B206) == 1, "");
_Static_assert(sizeof(struct B206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B206_extra_packed) == 1, "");
_Static_assert(sizeof(struct B206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_size) == 3, "");
_Static_assert(_Alignof(struct B206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B206,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B206,e) == 0, "");
#endif
_Static_assert(sizeof(B207) == 1, "");
_Static_assert(_Alignof(B207) == 1, "");
_Static_assert(sizeof(struct B207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B207_extra_packed) == 1, "");
_Static_assert(sizeof(struct B207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_size) == 3, "");
_Static_assert(_Alignof(struct B207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B207,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B207,e) == 0, "");
#endif
_Static_assert(sizeof(B208) == 1, "");
_Static_assert(_Alignof(B208) == 1, "");
_Static_assert(sizeof(struct B208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B208_extra_packed) == 1, "");
_Static_assert(sizeof(struct B208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_size) == 3, "");
_Static_assert(_Alignof(struct B208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B208,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B208,e) == 0, "");
#endif
_Static_assert(sizeof(B209) == 1, "");
_Static_assert(_Alignof(B209) == 1, "");
_Static_assert(sizeof(struct B209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B209_extra_packed) == 1, "");
_Static_assert(sizeof(struct B209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_size) == 3, "");
_Static_assert(_Alignof(struct B209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B209,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B209,e) == 0, "");
#endif
_Static_assert(sizeof(B210) == 1, "");
_Static_assert(_Alignof(B210) == 1, "");
_Static_assert(sizeof(struct B210_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B210_extra_packed) == 1, "");
_Static_assert(sizeof(struct B210_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_size) == 3, "");
_Static_assert(_Alignof(struct B210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B210,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B210,e) == 0, "");
#endif
_Static_assert(sizeof(B211) == 1, "");
_Static_assert(_Alignof(B211) == 1, "");
_Static_assert(sizeof(struct B211_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B211_extra_packed) == 1, "");
_Static_assert(sizeof(struct B211_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_size) == 3, "");
_Static_assert(_Alignof(struct B211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B211,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B211,e) == 0, "");
#endif
_Static_assert(sizeof(B212) == 1, "");
_Static_assert(_Alignof(B212) == 1, "");
_Static_assert(sizeof(struct B212_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B212_extra_packed) == 1, "");
_Static_assert(sizeof(struct B212_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_size) == 3, "");
_Static_assert(_Alignof(struct B212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B212,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B212,e) == 0, "");
#endif
_Static_assert(sizeof(B213) == 1, "");
_Static_assert(_Alignof(B213) == 1, "");
_Static_assert(sizeof(struct B213_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B213_extra_packed) == 1, "");
_Static_assert(sizeof(struct B213_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_size) == 3, "");
_Static_assert(_Alignof(struct B213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B213,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B213,e) == 0, "");
#endif
_Static_assert(sizeof(B214) == 1, "");
_Static_assert(_Alignof(B214) == 1, "");
_Static_assert(sizeof(struct B214_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B214_extra_packed) == 1, "");
_Static_assert(sizeof(struct B214_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_size) == 3, "");
_Static_assert(_Alignof(struct B214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B214,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B214,e) == 0, "");
#endif
_Static_assert(sizeof(B215) == 1, "");
_Static_assert(_Alignof(B215) == 1, "");
_Static_assert(sizeof(struct B215_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B215_extra_packed) == 1, "");
_Static_assert(sizeof(struct B215_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_size) == 3, "");
_Static_assert(_Alignof(struct B215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B215,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B215,e) == 0, "");
#endif
_Static_assert(sizeof(B216) == 1, "");
_Static_assert(_Alignof(B216) == 1, "");
_Static_assert(sizeof(struct B216_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B216_extra_packed) == 1, "");
_Static_assert(sizeof(struct B216_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_size) == 3, "");
_Static_assert(_Alignof(struct B216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B216,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B216,e) == 0, "");
#endif
_Static_assert(sizeof(B217) == 1, "");
_Static_assert(_Alignof(B217) == 1, "");
_Static_assert(sizeof(struct B217_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B217_extra_packed) == 1, "");
_Static_assert(sizeof(struct B217_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_size) == 3, "");
_Static_assert(_Alignof(struct B217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B217,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B217,e) == 0, "");
#endif
_Static_assert(sizeof(B218) == 1, "");
_Static_assert(_Alignof(B218) == 1, "");
_Static_assert(sizeof(struct B218_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B218_extra_packed) == 1, "");
_Static_assert(sizeof(struct B218_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_size) == 3, "");
_Static_assert(_Alignof(struct B218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B218,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B218,e) == 0, "");
#endif
_Static_assert(sizeof(B219) == 1, "");
_Static_assert(_Alignof(B219) == 1, "");
_Static_assert(sizeof(struct B219_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B219_extra_packed) == 1, "");
_Static_assert(sizeof(struct B219_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_size) == 3, "");
_Static_assert(_Alignof(struct B219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B219,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B219,e) == 0, "");
#endif
_Static_assert(sizeof(B300) == 1, "");
_Static_assert(_Alignof(B300) == 1, "");
_Static_assert(sizeof(struct B300_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B300_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B300_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B300_extra_packed) == 1, "");
_Static_assert(sizeof(struct B300_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B300_extra_size) == 3, "");
_Static_assert(_Alignof(struct B300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B300,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B300,e) == 0, "");
#endif
_Static_assert(sizeof(B301) == 1, "");
_Static_assert(_Alignof(B301) == 1, "");
_Static_assert(sizeof(struct B301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B301_extra_packed) == 1, "");
_Static_assert(sizeof(struct B301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_size) == 3, "");
_Static_assert(_Alignof(struct B301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B301,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B301,e) == 0, "");
#endif
_Static_assert(sizeof(B302) == 1, "");
_Static_assert(_Alignof(B302) == 1, "");
_Static_assert(sizeof(struct B302_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B302_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B302_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B302_extra_packed) == 1, "");
_Static_assert(sizeof(struct B302_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B302_extra_size) == 3, "");
_Static_assert(_Alignof(struct B302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B302,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B302,e) == 0, "");
#endif
_Static_assert(sizeof(B303) == 1, "");
_Static_assert(_Alignof(B303) == 1, "");
_Static_assert(sizeof(struct B303_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B303_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B303_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B303_extra_packed) == 1, "");
_Static_assert(sizeof(struct B303_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B303_extra_size) == 3, "");
_Static_assert(_Alignof(struct B303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B303,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B303,e) == 0, "");
#endif
_Static_assert(sizeof(B304) == 1, "");
_Static_assert(_Alignof(B304) == 1, "");
_Static_assert(sizeof(struct B304_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B304_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B304_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B304_extra_packed) == 1, "");
_Static_assert(sizeof(struct B304_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B304_extra_size) == 3, "");
_Static_assert(_Alignof(struct B304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B304,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B304,e) == 0, "");
#endif
_Static_assert(sizeof(B305) == 1, "");
_Static_assert(_Alignof(B305) == 1, "");
_Static_assert(sizeof(struct B305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B305_extra_packed) == 1, "");
_Static_assert(sizeof(struct B305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_size) == 3, "");
_Static_assert(_Alignof(struct B305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B305,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B305,e) == 0, "");
#endif
_Static_assert(sizeof(B306) == 1, "");
_Static_assert(_Alignof(B306) == 1, "");
_Static_assert(sizeof(struct B306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B306_extra_packed) == 1, "");
_Static_assert(sizeof(struct B306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_size) == 3, "");
_Static_assert(_Alignof(struct B306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B306,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B306,e) == 0, "");
#endif
_Static_assert(sizeof(B307) == 1, "");
_Static_assert(_Alignof(B307) == 1, "");
_Static_assert(sizeof(struct B307_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B307_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B307_extra_packed) == 1, "");
_Static_assert(sizeof(struct B307_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_size) == 3, "");
_Static_assert(_Alignof(struct B307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B307,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B307,e) == 0, "");
#endif
_Static_assert(sizeof(B308) == 1, "");
_Static_assert(_Alignof(B308) == 1, "");
_Static_assert(sizeof(struct B308_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B308_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B308_extra_packed) == 1, "");
_Static_assert(sizeof(struct B308_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_size) == 3, "");
_Static_assert(_Alignof(struct B308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B308,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B308,e) == 0, "");
#endif
_Static_assert(sizeof(B309) == 1, "");
_Static_assert(_Alignof(B309) == 1, "");
_Static_assert(sizeof(struct B309_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B309_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B309_extra_packed) == 1, "");
_Static_assert(sizeof(struct B309_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_size) == 3, "");
_Static_assert(_Alignof(struct B309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B309,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B309,e) == 0, "");
#endif
_Static_assert(sizeof(B310) == 4, "");
_Static_assert(_Alignof(B310) == 1, "");
_Static_assert(sizeof(struct B310_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B310_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B310_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B310_extra_packed) == 1, "");
_Static_assert(sizeof(struct B310_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B310_extra_size) == 6, "");
_Static_assert(_Alignof(struct B310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B310,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B310,e) == 0, "");
#endif
_Static_assert(sizeof(B311) == 4, "");
_Static_assert(_Alignof(B311) == 1, "");
_Static_assert(sizeof(struct B311_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B311_extra_packed) == 1, "");
_Static_assert(sizeof(struct B311_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_size) == 6, "");
_Static_assert(_Alignof(struct B311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B311,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B311,e) == 0, "");
#endif
_Static_assert(sizeof(B312) == 4, "");
_Static_assert(_Alignof(B312) == 1, "");
_Static_assert(sizeof(struct B312_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B312_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B312_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B312_extra_packed) == 1, "");
_Static_assert(sizeof(struct B312_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B312_extra_size) == 6, "");
_Static_assert(_Alignof(struct B312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B312,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B312,e) == 0, "");
#endif
_Static_assert(sizeof(B313) == 4, "");
_Static_assert(_Alignof(B313) == 1, "");
_Static_assert(sizeof(struct B313_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B313_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B313_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B313_extra_packed) == 1, "");
_Static_assert(sizeof(struct B313_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B313_extra_size) == 6, "");
_Static_assert(_Alignof(struct B313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B313,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B313,e) == 0, "");
#endif
_Static_assert(sizeof(B314) == 4, "");
_Static_assert(_Alignof(B314) == 1, "");
_Static_assert(sizeof(struct B314_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B314_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B314_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B314_extra_packed) == 1, "");
_Static_assert(sizeof(struct B314_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B314_extra_size) == 6, "");
_Static_assert(_Alignof(struct B314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B314,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B314,e) == 0, "");
#endif
_Static_assert(sizeof(B315) == 4, "");
_Static_assert(_Alignof(B315) == 1, "");
_Static_assert(sizeof(struct B315_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B315_extra_packed) == 1, "");
_Static_assert(sizeof(struct B315_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_size) == 6, "");
_Static_assert(_Alignof(struct B315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B315,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B315,e) == 0, "");
#endif
_Static_assert(sizeof(B316) == 4, "");
_Static_assert(_Alignof(B316) == 1, "");
_Static_assert(sizeof(struct B316_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B316_extra_packed) == 1, "");
_Static_assert(sizeof(struct B316_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_size) == 6, "");
_Static_assert(_Alignof(struct B316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B316,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B316,e) == 0, "");
#endif
_Static_assert(sizeof(B317) == 4, "");
_Static_assert(_Alignof(B317) == 1, "");
_Static_assert(sizeof(struct B317_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B317_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B317_extra_packed) == 1, "");
_Static_assert(sizeof(struct B317_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_size) == 6, "");
_Static_assert(_Alignof(struct B317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B317,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B317,e) == 0, "");
#endif
_Static_assert(sizeof(B318) == 4, "");
_Static_assert(_Alignof(B318) == 1, "");
_Static_assert(sizeof(struct B318_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B318_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B318_extra_packed) == 1, "");
_Static_assert(sizeof(struct B318_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_size) == 6, "");
_Static_assert(_Alignof(struct B318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B318,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B318,e) == 0, "");
#endif
_Static_assert(sizeof(B319) == 4, "");
_Static_assert(_Alignof(B319) == 1, "");
_Static_assert(sizeof(struct B319_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B319_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B319_extra_packed) == 1, "");
_Static_assert(sizeof(struct B319_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_size) == 6, "");
_Static_assert(_Alignof(struct B319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B319,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B319,e) == 0, "");
#endif
_Static_assert(sizeof(B410) == 4, "");
_Static_assert(_Alignof(B410) == 2, "");
_Static_assert(sizeof(struct B410_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B410_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B410_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B410_extra_packed) == 1, "");
_Static_assert(sizeof(struct B410_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B410_extra_size) == 6, "");
_Static_assert(_Alignof(struct B410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B410,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B410,e) == 0, "");
#endif
_Static_assert(sizeof(B411) == 4, "");
_Static_assert(_Alignof(B411) == 1, "");
_Static_assert(sizeof(struct B411_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B411_extra_packed) == 1, "");
_Static_assert(sizeof(struct B411_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_size) == 6, "");
_Static_assert(_Alignof(struct B411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B411,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B411,e) == 0, "");
#endif
_Static_assert(sizeof(B412) == 4, "");
_Static_assert(_Alignof(B412) == 2, "");
_Static_assert(sizeof(struct B412_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B412_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B412_extra_packed) == 1, "");
_Static_assert(sizeof(struct B412_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B412_extra_size) == 6, "");
_Static_assert(_Alignof(struct B412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B412,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B412,e) == 0, "");
#endif
_Static_assert(sizeof(B413) == 4, "");
_Static_assert(_Alignof(B413) == 4, "");
_Static_assert(sizeof(struct B413_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B413_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B413_extra_packed) == 1, "");
_Static_assert(sizeof(struct B413_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B413_extra_size) == 6, "");
_Static_assert(_Alignof(struct B413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B413,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B413,e) == 0, "");
#endif
_Static_assert(sizeof(B414) == 4, "");
_Static_assert(_Alignof(B414) == 4, "");
_Static_assert(sizeof(struct B414_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B414_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B414_extra_packed) == 1, "");
_Static_assert(sizeof(struct B414_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B414_extra_size) == 6, "");
_Static_assert(_Alignof(struct B414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B414,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B414,e) == 0, "");
#endif
_Static_assert(sizeof(B415) == 4, "");
_Static_assert(_Alignof(B415) == 2, "");
_Static_assert(sizeof(struct B415_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B415_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B415_extra_packed) == 1, "");
_Static_assert(sizeof(struct B415_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B415_extra_size) == 6, "");
_Static_assert(_Alignof(struct B415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B415,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B415,e) == 0, "");
#endif
_Static_assert(sizeof(B416) == 4, "");
_Static_assert(_Alignof(B416) == 1, "");
_Static_assert(sizeof(struct B416_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B416_extra_packed) == 1, "");
_Static_assert(sizeof(struct B416_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_size) == 6, "");
_Static_assert(_Alignof(struct B416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B416,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B416,e) == 0, "");
#endif
_Static_assert(sizeof(B417) == 4, "");
_Static_assert(_Alignof(B417) == 2, "");
_Static_assert(sizeof(struct B417_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B417_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B417_extra_packed) == 1, "");
_Static_assert(sizeof(struct B417_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B417_extra_size) == 6, "");
_Static_assert(_Alignof(struct B417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B417,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B417,e) == 0, "");
#endif
_Static_assert(sizeof(B418) == 4, "");
_Static_assert(_Alignof(B418) == 4, "");
_Static_assert(sizeof(struct B418_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B418_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B418_extra_packed) == 1, "");
_Static_assert(sizeof(struct B418_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B418_extra_size) == 6, "");
_Static_assert(_Alignof(struct B418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B418,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B418,e) == 0, "");
#endif
_Static_assert(sizeof(B419) == 4, "");
_Static_assert(_Alignof(B419) == 4, "");
_Static_assert(sizeof(struct B419_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B419_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B419_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B419_extra_packed) == 1, "");
_Static_assert(sizeof(struct B419_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B419_extra_size) == 6, "");
_Static_assert(_Alignof(struct B419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B419,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B419,e) == 0, "");
#endif
_Static_assert(sizeof(B510) == 4, "");
_Static_assert(_Alignof(B510) == 1, "");
_Static_assert(sizeof(struct B510_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B510_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B510_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B510_extra_packed) == 1, "");
_Static_assert(sizeof(struct B510_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B510_extra_size) == 6, "");
_Static_assert(_Alignof(struct B510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B510,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B510,e) == 0, "");
#endif
_Static_assert(sizeof(B511) == 4, "");
_Static_assert(_Alignof(B511) == 1, "");
_Static_assert(sizeof(struct B511_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B511_extra_packed) == 1, "");
_Static_assert(sizeof(struct B511_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_size) == 6, "");
_Static_assert(_Alignof(struct B511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B511,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B511,e) == 0, "");
#endif
_Static_assert(sizeof(B512) == 4, "");
_Static_assert(_Alignof(B512) == 1, "");
_Static_assert(sizeof(struct B512_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B512_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B512_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B512_extra_packed) == 1, "");
_Static_assert(sizeof(struct B512_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B512_extra_size) == 6, "");
_Static_assert(_Alignof(struct B512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B512,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B512,e) == 0, "");
#endif
_Static_assert(sizeof(B513) == 4, "");
_Static_assert(_Alignof(B513) == 1, "");
_Static_assert(sizeof(struct B513_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B513_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B513_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B513_extra_packed) == 1, "");
_Static_assert(sizeof(struct B513_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B513_extra_size) == 6, "");
_Static_assert(_Alignof(struct B513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B513,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B513,e) == 0, "");
#endif
_Static_assert(sizeof(B514) == 4, "");
_Static_assert(_Alignof(B514) == 1, "");
_Static_assert(sizeof(struct B514_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B514_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B514_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B514_extra_packed) == 1, "");
_Static_assert(sizeof(struct B514_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B514_extra_size) == 6, "");
_Static_assert(_Alignof(struct B514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B514,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B514,e) == 0, "");
#endif
_Static_assert(sizeof(B515) == 4, "");
_Static_assert(_Alignof(B515) == 1, "");
_Static_assert(sizeof(struct B515_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B515_extra_packed) == 1, "");
_Static_assert(sizeof(struct B515_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_size) == 6, "");
_Static_assert(_Alignof(struct B515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B515,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B515,e) == 0, "");
#endif
_Static_assert(sizeof(B516) == 4, "");
_Static_assert(_Alignof(B516) == 1, "");
_Static_assert(sizeof(struct B516_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B516_extra_packed) == 1, "");
_Static_assert(sizeof(struct B516_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_size) == 6, "");
_Static_assert(_Alignof(struct B516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B516,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B516,e) == 0, "");
#endif
_Static_assert(sizeof(B517) == 4, "");
_Static_assert(_Alignof(B517) == 1, "");
_Static_assert(sizeof(struct B517_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B517_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B517_extra_packed) == 1, "");
_Static_assert(sizeof(struct B517_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_size) == 6, "");
_Static_assert(_Alignof(struct B517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B517,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B517,e) == 0, "");
#endif
_Static_assert(sizeof(B518) == 4, "");
_Static_assert(_Alignof(B518) == 1, "");
_Static_assert(sizeof(struct B518_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B518_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B518_extra_packed) == 1, "");
_Static_assert(sizeof(struct B518_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_size) == 6, "");
_Static_assert(_Alignof(struct B518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B518,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B518,e) == 0, "");
#endif
_Static_assert(sizeof(B519) == 4, "");
_Static_assert(_Alignof(B519) == 1, "");
_Static_assert(sizeof(struct B519_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B519_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B519_extra_packed) == 1, "");
_Static_assert(sizeof(struct B519_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_size) == 6, "");
_Static_assert(_Alignof(struct B519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B519,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B519,e) == 0, "");
#endif
// MAPPING|SEVEN|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(SEVEN)
_Static_assert(sizeof(A000) == 2, "");
_Static_assert(_Alignof(A000) == 2, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 4, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A000,e) == 2, "");
#endif
_Static_assert(sizeof(A001) == 1, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 3, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A001,e) == 2, "");
#endif
_Static_assert(sizeof(A002) == 2, "");
_Static_assert(_Alignof(A002) == 2, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 4, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A002,e) == 2, "");
#endif
_Static_assert(sizeof(A003) == 4, "");
_Static_assert(_Alignof(A003) == 4, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 6, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A003,e) == 2, "");
#endif
_Static_assert(sizeof(A004) == 4, "");
_Static_assert(_Alignof(A004) == 4, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 6, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A004,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A004,e) == 2, "");
#endif
_Static_assert(sizeof(A005) == 1, "");
_Static_assert(_Alignof(A005) == 1, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 3, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A005,e) == 2, "");
#endif
_Static_assert(sizeof(A006) == 1, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 3, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A006,e) == 2, "");
#endif
_Static_assert(sizeof(A007) == 1, "");
_Static_assert(_Alignof(A007) == 1, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 3, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A007,e) == 2, "");
#endif
_Static_assert(sizeof(A008) == 1, "");
_Static_assert(_Alignof(A008) == 1, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 3, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A008,e) == 2, "");
#endif
_Static_assert(sizeof(A009) == 1, "");
_Static_assert(_Alignof(A009) == 1, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 3, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A009,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A009,e) == 2, "");
#endif
_Static_assert(sizeof(A010) == 4, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 6, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A010,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A010,e) == 24, "");
#endif
_Static_assert(sizeof(A011) == 3, "");
_Static_assert(_Alignof(A011) == 1, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 5, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A011,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A011,e) == 16, "");
#endif
_Static_assert(sizeof(A012) == 4, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 6, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A012,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A012,e) == 24, "");
#endif
_Static_assert(sizeof(A013) == 8, "");
_Static_assert(_Alignof(A013) == 4, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A013_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 10, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A013,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A013,e) == 40, "");
#endif
_Static_assert(sizeof(A014) == 8, "");
_Static_assert(_Alignof(A014) == 4, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A014_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 10, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A014,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A014,e) == 40, "");
#endif
_Static_assert(sizeof(A015) == 4, "");
_Static_assert(_Alignof(A015) == 1, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 6, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A015,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A015,e) == 24, "");
#endif
_Static_assert(sizeof(A016) == 3, "");
_Static_assert(_Alignof(A016) == 1, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 5, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A016,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A016,e) == 16, "");
#endif
_Static_assert(sizeof(A017) == 4, "");
_Static_assert(_Alignof(A017) == 1, "");
_Static_assert(sizeof(struct A017_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A017_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A017_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A017_extra_packed) == 1, "");
_Static_assert(sizeof(struct A017_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A017_extra_size) == 6, "");
_Static_assert(_Alignof(struct A017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A017,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A017,e) == 24, "");
#endif
_Static_assert(sizeof(A018) == 6, "");
_Static_assert(_Alignof(A018) == 1, "");
_Static_assert(sizeof(struct A018_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A018_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A018_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A018_extra_packed) == 1, "");
_Static_assert(sizeof(struct A018_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A018_extra_size) == 8, "");
_Static_assert(_Alignof(struct A018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A018,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A018,e) == 40, "");
#endif
_Static_assert(sizeof(A019) == 6, "");
_Static_assert(_Alignof(A019) == 1, "");
_Static_assert(sizeof(struct A019_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A019_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A019_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A019_extra_packed) == 1, "");
_Static_assert(sizeof(struct A019_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A019_extra_size) == 8, "");
_Static_assert(_Alignof(struct A019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A019,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A019,e) == 40, "");
#endif
_Static_assert(sizeof(A100) == 12, "");
_Static_assert(_Alignof(A100) == 4, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A100_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 14, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A100,e) == 64, "");
#endif
_Static_assert(sizeof(A101) == 6, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 8, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A101,e) == 40, "");
#endif
_Static_assert(sizeof(A102) == 8, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 10, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A102,e) == 48, "");
#endif
_Static_assert(sizeof(A103) == 12, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 14, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A103,e) == 64, "");
#endif
_Static_assert(sizeof(A104) == 12, "");
_Static_assert(_Alignof(A104) == 4, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A104_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 14, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A104,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A104,e) == 64, "");
#endif
_Static_assert(sizeof(A105) == 7, "");
_Static_assert(_Alignof(A105) == 1, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_packed) == 7, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 8, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 9, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A105,e) == 48, "");
#endif
_Static_assert(sizeof(A106) == 6, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 8, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A106,e) == 40, "");
#endif
_Static_assert(sizeof(A107) == 7, "");
_Static_assert(_Alignof(A107) == 1, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_packed) == 7, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 8, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 9, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A107,e) == 48, "");
#endif
_Static_assert(sizeof(A108) == 9, "");
_Static_assert(_Alignof(A108) == 1, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 11, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A108,e) == 64, "");
#endif
_Static_assert(sizeof(A109) == 9, "");
_Static_assert(_Alignof(A109) == 1, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 11, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A109,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A109,e) == 64, "");
#endif
_Static_assert(sizeof(A110) == 12, "");
_Static_assert(_Alignof(A110) == 4, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A110_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 14, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A110,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A110,e) == 64, "");
#endif
_Static_assert(sizeof(A111) == 6, "");
_Static_assert(_Alignof(A111) == 1, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 8, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A111,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A111,e) == 40, "");
#endif
_Static_assert(sizeof(A112) == 8, "");
_Static_assert(_Alignof(A112) == 2, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A112_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 10, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A112,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A112,e) == 48, "");
#endif
_Static_assert(sizeof(A113) == 12, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 14, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A113,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A113,e) == 64, "");
#endif
_Static_assert(sizeof(A114) == 12, "");
_Static_assert(_Alignof(A114) == 4, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A114_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 14, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A114,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A114,e) == 64, "");
#endif
_Static_assert(sizeof(A115) == 7, "");
_Static_assert(_Alignof(A115) == 1, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_packed) == 7, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 8, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 9, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A115,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A115,e) == 48, "");
#endif
_Static_assert(sizeof(A116) == 6, "");
_Static_assert(_Alignof(A116) == 1, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 8, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A116,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A116,e) == 40, "");
#endif
_Static_assert(sizeof(A117) == 7, "");
_Static_assert(_Alignof(A117) == 1, "");
_Static_assert(sizeof(struct A117_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A117_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A117_extra_packed) == 7, "");
_Static_assert(_Alignof(struct A117_extra_packed) == 1, "");
_Static_assert(sizeof(struct A117_extra_required_alignment) == 8, "");
_Static_assert(_Alignof(struct A117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A117_extra_size) == 9, "");
_Static_assert(_Alignof(struct A117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A117,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A117,e) == 48, "");
#endif
_Static_assert(sizeof(A118) == 9, "");
_Static_assert(_Alignof(A118) == 1, "");
_Static_assert(sizeof(struct A118_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A118_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A118_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A118_extra_packed) == 1, "");
_Static_assert(sizeof(struct A118_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A118_extra_size) == 11, "");
_Static_assert(_Alignof(struct A118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A118,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A118,e) == 64, "");
#endif
_Static_assert(sizeof(A119) == 9, "");
_Static_assert(_Alignof(A119) == 1, "");
_Static_assert(sizeof(struct A119_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A119_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A119_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A119_extra_packed) == 1, "");
_Static_assert(sizeof(struct A119_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A119_extra_size) == 11, "");
_Static_assert(_Alignof(struct A119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A119,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A119,e) == 64, "");
#endif
_Static_assert(sizeof(A200) == 1, "");
_Static_assert(_Alignof(A200) == 1, "");
_Static_assert(sizeof(struct A200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A200_extra_packed) == 1, "");
_Static_assert(sizeof(struct A200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_size) == 3, "");
_Static_assert(_Alignof(struct A200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A200,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A200,e) == 2, "");
#endif
_Static_assert(sizeof(A201) == 1, "");
_Static_assert(_Alignof(A201) == 1, "");
_Static_assert(sizeof(struct A201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A201_extra_packed) == 1, "");
_Static_assert(sizeof(struct A201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_size) == 3, "");
_Static_assert(_Alignof(struct A201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A201,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A201,e) == 2, "");
#endif
_Static_assert(sizeof(A202) == 1, "");
_Static_assert(_Alignof(A202) == 1, "");
_Static_assert(sizeof(struct A202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A202_extra_packed) == 1, "");
_Static_assert(sizeof(struct A202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_size) == 3, "");
_Static_assert(_Alignof(struct A202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A202,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A202,e) == 2, "");
#endif
_Static_assert(sizeof(A203) == 1, "");
_Static_assert(_Alignof(A203) == 1, "");
_Static_assert(sizeof(struct A203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A203_extra_packed) == 1, "");
_Static_assert(sizeof(struct A203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_size) == 3, "");
_Static_assert(_Alignof(struct A203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A203,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A203,e) == 2, "");
#endif
_Static_assert(sizeof(A204) == 1, "");
_Static_assert(_Alignof(A204) == 1, "");
_Static_assert(sizeof(struct A204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A204_extra_packed) == 1, "");
_Static_assert(sizeof(struct A204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_size) == 3, "");
_Static_assert(_Alignof(struct A204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A204,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A204,e) == 2, "");
#endif
_Static_assert(sizeof(A205) == 1, "");
_Static_assert(_Alignof(A205) == 1, "");
_Static_assert(sizeof(struct A205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A205_extra_packed) == 1, "");
_Static_assert(sizeof(struct A205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_size) == 3, "");
_Static_assert(_Alignof(struct A205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A205,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A205,e) == 2, "");
#endif
_Static_assert(sizeof(A206) == 1, "");
_Static_assert(_Alignof(A206) == 1, "");
_Static_assert(sizeof(struct A206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A206_extra_packed) == 1, "");
_Static_assert(sizeof(struct A206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_size) == 3, "");
_Static_assert(_Alignof(struct A206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A206,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A206,e) == 2, "");
#endif
_Static_assert(sizeof(A207) == 1, "");
_Static_assert(_Alignof(A207) == 1, "");
_Static_assert(sizeof(struct A207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A207_extra_packed) == 1, "");
_Static_assert(sizeof(struct A207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_size) == 3, "");
_Static_assert(_Alignof(struct A207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A207,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A207,e) == 2, "");
#endif
_Static_assert(sizeof(A208) == 1, "");
_Static_assert(_Alignof(A208) == 1, "");
_Static_assert(sizeof(struct A208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A208_extra_packed) == 1, "");
_Static_assert(sizeof(struct A208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_size) == 3, "");
_Static_assert(_Alignof(struct A208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A208,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A208,e) == 2, "");
#endif
_Static_assert(sizeof(A209) == 1, "");
_Static_assert(_Alignof(A209) == 1, "");
_Static_assert(sizeof(struct A209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A209_extra_packed) == 1, "");
_Static_assert(sizeof(struct A209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_size) == 3, "");
_Static_assert(_Alignof(struct A209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A209,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A209,e) == 2, "");
#endif
_Static_assert(sizeof(A210) == 3, "");
_Static_assert(_Alignof(A210) == 1, "");
_Static_assert(sizeof(struct A210_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A210_extra_packed) == 1, "");
_Static_assert(sizeof(struct A210_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_size) == 5, "");
_Static_assert(_Alignof(struct A210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A210,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A210,e) == 16, "");
#endif
_Static_assert(sizeof(A211) == 3, "");
_Static_assert(_Alignof(A211) == 1, "");
_Static_assert(sizeof(struct A211_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A211_extra_packed) == 1, "");
_Static_assert(sizeof(struct A211_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_size) == 5, "");
_Static_assert(_Alignof(struct A211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A211,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A211,e) == 16, "");
#endif
_Static_assert(sizeof(A212) == 3, "");
_Static_assert(_Alignof(A212) == 1, "");
_Static_assert(sizeof(struct A212_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A212_extra_packed) == 1, "");
_Static_assert(sizeof(struct A212_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_size) == 5, "");
_Static_assert(_Alignof(struct A212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A212,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A212,e) == 16, "");
#endif
_Static_assert(sizeof(A213) == 3, "");
_Static_assert(_Alignof(A213) == 1, "");
_Static_assert(sizeof(struct A213_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A213_extra_packed) == 1, "");
_Static_assert(sizeof(struct A213_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_size) == 5, "");
_Static_assert(_Alignof(struct A213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A213,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A213,e) == 16, "");
#endif
_Static_assert(sizeof(A214) == 3, "");
_Static_assert(_Alignof(A214) == 1, "");
_Static_assert(sizeof(struct A214_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A214_extra_packed) == 1, "");
_Static_assert(sizeof(struct A214_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_size) == 5, "");
_Static_assert(_Alignof(struct A214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A214,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A214,e) == 16, "");
#endif
_Static_assert(sizeof(A215) == 3, "");
_Static_assert(_Alignof(A215) == 1, "");
_Static_assert(sizeof(struct A215_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A215_extra_packed) == 1, "");
_Static_assert(sizeof(struct A215_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_size) == 5, "");
_Static_assert(_Alignof(struct A215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A215,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A215,e) == 16, "");
#endif
_Static_assert(sizeof(A216) == 3, "");
_Static_assert(_Alignof(A216) == 1, "");
_Static_assert(sizeof(struct A216_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A216_extra_packed) == 1, "");
_Static_assert(sizeof(struct A216_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_size) == 5, "");
_Static_assert(_Alignof(struct A216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A216,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A216,e) == 16, "");
#endif
_Static_assert(sizeof(A217) == 3, "");
_Static_assert(_Alignof(A217) == 1, "");
_Static_assert(sizeof(struct A217_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A217_extra_packed) == 1, "");
_Static_assert(sizeof(struct A217_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_size) == 5, "");
_Static_assert(_Alignof(struct A217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A217,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A217,e) == 16, "");
#endif
_Static_assert(sizeof(A218) == 3, "");
_Static_assert(_Alignof(A218) == 1, "");
_Static_assert(sizeof(struct A218_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A218_extra_packed) == 1, "");
_Static_assert(sizeof(struct A218_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_size) == 5, "");
_Static_assert(_Alignof(struct A218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A218,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A218,e) == 16, "");
#endif
_Static_assert(sizeof(A219) == 3, "");
_Static_assert(_Alignof(A219) == 1, "");
_Static_assert(sizeof(struct A219_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A219_extra_packed) == 1, "");
_Static_assert(sizeof(struct A219_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_size) == 5, "");
_Static_assert(_Alignof(struct A219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A219,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A219,e) == 16, "");
#endif
_Static_assert(sizeof(A300) == 12, "");
_Static_assert(_Alignof(A300) == 4, "");
_Static_assert(sizeof(struct A300_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A300_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A300_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A300_extra_packed) == 1, "");
_Static_assert(sizeof(struct A300_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A300_extra_size) == 14, "");
_Static_assert(_Alignof(struct A300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A300,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A300,e) == 64, "");
#endif
_Static_assert(sizeof(A301) == 6, "");
_Static_assert(_Alignof(A301) == 1, "");
_Static_assert(sizeof(struct A301_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A301_extra_packed) == 1, "");
_Static_assert(sizeof(struct A301_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_size) == 8, "");
_Static_assert(_Alignof(struct A301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A301,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A301,e) == 40, "");
#endif
_Static_assert(sizeof(A302) == 8, "");
_Static_assert(_Alignof(A302) == 2, "");
_Static_assert(sizeof(struct A302_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A302_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A302_extra_packed) == 1, "");
_Static_assert(sizeof(struct A302_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A302_extra_size) == 10, "");
_Static_assert(_Alignof(struct A302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A302,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A302,e) == 48, "");
#endif
_Static_assert(sizeof(A303) == 12, "");
_Static_assert(_Alignof(A303) == 4, "");
_Static_assert(sizeof(struct A303_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A303_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A303_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A303_extra_packed) == 1, "");
_Static_assert(sizeof(struct A303_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A303_extra_size) == 14, "");
_Static_assert(_Alignof(struct A303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A303,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A303,e) == 64, "");
#endif
_Static_assert(sizeof(A304) == 12, "");
_Static_assert(_Alignof(A304) == 4, "");
_Static_assert(sizeof(struct A304_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A304_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A304_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A304_extra_packed) == 1, "");
_Static_assert(sizeof(struct A304_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A304_extra_size) == 14, "");
_Static_assert(_Alignof(struct A304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A304,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A304,e) == 64, "");
#endif
_Static_assert(sizeof(A305) == 6, "");
_Static_assert(_Alignof(A305) == 1, "");
_Static_assert(sizeof(struct A305_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A305_extra_packed) == 1, "");
_Static_assert(sizeof(struct A305_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_size) == 8, "");
_Static_assert(_Alignof(struct A305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A305,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A305,e) == 40, "");
#endif
_Static_assert(sizeof(A306) == 6, "");
_Static_assert(_Alignof(A306) == 1, "");
_Static_assert(sizeof(struct A306_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A306_extra_packed) == 1, "");
_Static_assert(sizeof(struct A306_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_size) == 8, "");
_Static_assert(_Alignof(struct A306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A306,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A306,e) == 40, "");
#endif
_Static_assert(sizeof(A307) == 6, "");
_Static_assert(_Alignof(A307) == 1, "");
_Static_assert(sizeof(struct A307_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A307_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A307_extra_packed) == 1, "");
_Static_assert(sizeof(struct A307_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_size) == 8, "");
_Static_assert(_Alignof(struct A307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A307,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A307,e) == 40, "");
#endif
_Static_assert(sizeof(A308) == 6, "");
_Static_assert(_Alignof(A308) == 1, "");
_Static_assert(sizeof(struct A308_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A308_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A308_extra_packed) == 1, "");
_Static_assert(sizeof(struct A308_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_size) == 8, "");
_Static_assert(_Alignof(struct A308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A308,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A308,e) == 40, "");
#endif
_Static_assert(sizeof(A309) == 6, "");
_Static_assert(_Alignof(A309) == 1, "");
_Static_assert(sizeof(struct A309_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A309_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A309_extra_packed) == 1, "");
_Static_assert(sizeof(struct A309_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_size) == 8, "");
_Static_assert(_Alignof(struct A309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A309,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A309,e) == 40, "");
#endif
_Static_assert(sizeof(A310) == 12, "");
_Static_assert(_Alignof(A310) == 4, "");
_Static_assert(sizeof(struct A310_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A310_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A310_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A310_extra_packed) == 1, "");
_Static_assert(sizeof(struct A310_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A310_extra_size) == 14, "");
_Static_assert(_Alignof(struct A310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A310,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A310,e) == 64, "");
#endif
_Static_assert(sizeof(A311) == 6, "");
_Static_assert(_Alignof(A311) == 1, "");
_Static_assert(sizeof(struct A311_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A311_extra_packed) == 1, "");
_Static_assert(sizeof(struct A311_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_size) == 8, "");
_Static_assert(_Alignof(struct A311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A311,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A311,e) == 40, "");
#endif
_Static_assert(sizeof(A312) == 8, "");
_Static_assert(_Alignof(A312) == 2, "");
_Static_assert(sizeof(struct A312_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A312_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A312_extra_packed) == 1, "");
_Static_assert(sizeof(struct A312_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A312_extra_size) == 10, "");
_Static_assert(_Alignof(struct A312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A312,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A312,e) == 48, "");
#endif
_Static_assert(sizeof(A313) == 12, "");
_Static_assert(_Alignof(A313) == 4, "");
_Static_assert(sizeof(struct A313_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A313_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A313_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A313_extra_packed) == 1, "");
_Static_assert(sizeof(struct A313_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A313_extra_size) == 14, "");
_Static_assert(_Alignof(struct A313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A313,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A313,e) == 64, "");
#endif
_Static_assert(sizeof(A314) == 12, "");
_Static_assert(_Alignof(A314) == 4, "");
_Static_assert(sizeof(struct A314_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A314_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A314_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A314_extra_packed) == 1, "");
_Static_assert(sizeof(struct A314_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A314_extra_size) == 14, "");
_Static_assert(_Alignof(struct A314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A314,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A314,e) == 64, "");
#endif
_Static_assert(sizeof(A315) == 6, "");
_Static_assert(_Alignof(A315) == 1, "");
_Static_assert(sizeof(struct A315_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A315_extra_packed) == 1, "");
_Static_assert(sizeof(struct A315_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_size) == 8, "");
_Static_assert(_Alignof(struct A315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A315,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A315,e) == 40, "");
#endif
_Static_assert(sizeof(A316) == 6, "");
_Static_assert(_Alignof(A316) == 1, "");
_Static_assert(sizeof(struct A316_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A316_extra_packed) == 1, "");
_Static_assert(sizeof(struct A316_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_size) == 8, "");
_Static_assert(_Alignof(struct A316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A316,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A316,e) == 40, "");
#endif
_Static_assert(sizeof(A317) == 6, "");
_Static_assert(_Alignof(A317) == 1, "");
_Static_assert(sizeof(struct A317_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A317_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A317_extra_packed) == 1, "");
_Static_assert(sizeof(struct A317_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_size) == 8, "");
_Static_assert(_Alignof(struct A317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A317,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A317,e) == 40, "");
#endif
_Static_assert(sizeof(A318) == 6, "");
_Static_assert(_Alignof(A318) == 1, "");
_Static_assert(sizeof(struct A318_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A318_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A318_extra_packed) == 1, "");
_Static_assert(sizeof(struct A318_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_size) == 8, "");
_Static_assert(_Alignof(struct A318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A318,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A318,e) == 40, "");
#endif
_Static_assert(sizeof(A319) == 6, "");
_Static_assert(_Alignof(A319) == 1, "");
_Static_assert(sizeof(struct A319_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A319_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A319_extra_packed) == 1, "");
_Static_assert(sizeof(struct A319_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_size) == 8, "");
_Static_assert(_Alignof(struct A319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A319,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A319,e) == 40, "");
#endif
_Static_assert(sizeof(A410) == 12, "");
_Static_assert(_Alignof(A410) == 4, "");
_Static_assert(sizeof(struct A410_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A410_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A410_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A410_extra_packed) == 1, "");
_Static_assert(sizeof(struct A410_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A410_extra_size) == 14, "");
_Static_assert(_Alignof(struct A410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A410,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A410,e) == 64, "");
#endif
_Static_assert(sizeof(A411) == 6, "");
_Static_assert(_Alignof(A411) == 1, "");
_Static_assert(sizeof(struct A411_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A411_extra_packed) == 1, "");
_Static_assert(sizeof(struct A411_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_size) == 8, "");
_Static_assert(_Alignof(struct A411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A411,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A411,e) == 40, "");
#endif
_Static_assert(sizeof(A412) == 8, "");
_Static_assert(_Alignof(A412) == 2, "");
_Static_assert(sizeof(struct A412_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A412_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A412_extra_packed) == 1, "");
_Static_assert(sizeof(struct A412_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A412_extra_size) == 10, "");
_Static_assert(_Alignof(struct A412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A412,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A412,e) == 48, "");
#endif
_Static_assert(sizeof(A413) == 12, "");
_Static_assert(_Alignof(A413) == 4, "");
_Static_assert(sizeof(struct A413_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A413_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A413_extra_packed) == 1, "");
_Static_assert(sizeof(struct A413_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A413_extra_size) == 14, "");
_Static_assert(_Alignof(struct A413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A413,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A413,e) == 64, "");
#endif
_Static_assert(sizeof(A414) == 12, "");
_Static_assert(_Alignof(A414) == 4, "");
_Static_assert(sizeof(struct A414_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A414_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A414_extra_packed) == 1, "");
_Static_assert(sizeof(struct A414_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A414_extra_size) == 14, "");
_Static_assert(_Alignof(struct A414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A414,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A414,e) == 64, "");
#endif
_Static_assert(sizeof(A415) == 7, "");
_Static_assert(_Alignof(A415) == 1, "");
_Static_assert(sizeof(struct A415_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A415_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A415_extra_packed) == 7, "");
_Static_assert(_Alignof(struct A415_extra_packed) == 1, "");
_Static_assert(sizeof(struct A415_extra_required_alignment) == 8, "");
_Static_assert(_Alignof(struct A415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A415_extra_size) == 9, "");
_Static_assert(_Alignof(struct A415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A415,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A415,e) == 48, "");
#endif
_Static_assert(sizeof(A416) == 6, "");
_Static_assert(_Alignof(A416) == 1, "");
_Static_assert(sizeof(struct A416_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A416_extra_packed) == 1, "");
_Static_assert(sizeof(struct A416_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_size) == 8, "");
_Static_assert(_Alignof(struct A416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A416,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A416,e) == 40, "");
#endif
_Static_assert(sizeof(A417) == 7, "");
_Static_assert(_Alignof(A417) == 1, "");
_Static_assert(sizeof(struct A417_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A417_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A417_extra_packed) == 7, "");
_Static_assert(_Alignof(struct A417_extra_packed) == 1, "");
_Static_assert(sizeof(struct A417_extra_required_alignment) == 8, "");
_Static_assert(_Alignof(struct A417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A417_extra_size) == 9, "");
_Static_assert(_Alignof(struct A417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A417,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A417,e) == 48, "");
#endif
_Static_assert(sizeof(A418) == 9, "");
_Static_assert(_Alignof(A418) == 1, "");
_Static_assert(sizeof(struct A418_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A418_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A418_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A418_extra_packed) == 1, "");
_Static_assert(sizeof(struct A418_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A418_extra_size) == 11, "");
_Static_assert(_Alignof(struct A418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A418,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A418,e) == 64, "");
#endif
_Static_assert(sizeof(A419) == 9, "");
_Static_assert(_Alignof(A419) == 1, "");
_Static_assert(sizeof(struct A419_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A419_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A419_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A419_extra_packed) == 1, "");
_Static_assert(sizeof(struct A419_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A419_extra_size) == 11, "");
_Static_assert(_Alignof(struct A419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A419,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A419,e) == 64, "");
#endif
_Static_assert(sizeof(A510) == 12, "");
_Static_assert(_Alignof(A510) == 4, "");
_Static_assert(sizeof(struct A510_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A510_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A510_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A510_extra_packed) == 1, "");
_Static_assert(sizeof(struct A510_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A510_extra_size) == 14, "");
_Static_assert(_Alignof(struct A510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A510,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A510,e) == 64, "");
#endif
_Static_assert(sizeof(A511) == 6, "");
_Static_assert(_Alignof(A511) == 1, "");
_Static_assert(sizeof(struct A511_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A511_extra_packed) == 1, "");
_Static_assert(sizeof(struct A511_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_size) == 8, "");
_Static_assert(_Alignof(struct A511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A511,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A511,e) == 40, "");
#endif
_Static_assert(sizeof(A512) == 8, "");
_Static_assert(_Alignof(A512) == 2, "");
_Static_assert(sizeof(struct A512_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A512_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A512_extra_packed) == 1, "");
_Static_assert(sizeof(struct A512_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A512_extra_size) == 10, "");
_Static_assert(_Alignof(struct A512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A512,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A512,e) == 48, "");
#endif
_Static_assert(sizeof(A513) == 12, "");
_Static_assert(_Alignof(A513) == 4, "");
_Static_assert(sizeof(struct A513_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A513_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A513_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A513_extra_packed) == 1, "");
_Static_assert(sizeof(struct A513_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A513_extra_size) == 14, "");
_Static_assert(_Alignof(struct A513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A513,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A513,e) == 64, "");
#endif
_Static_assert(sizeof(A514) == 12, "");
_Static_assert(_Alignof(A514) == 4, "");
_Static_assert(sizeof(struct A514_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A514_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A514_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A514_extra_packed) == 1, "");
_Static_assert(sizeof(struct A514_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A514_extra_size) == 14, "");
_Static_assert(_Alignof(struct A514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A514,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A514,e) == 64, "");
#endif
_Static_assert(sizeof(A515) == 6, "");
_Static_assert(_Alignof(A515) == 1, "");
_Static_assert(sizeof(struct A515_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A515_extra_packed) == 1, "");
_Static_assert(sizeof(struct A515_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_size) == 8, "");
_Static_assert(_Alignof(struct A515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A515,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A515,e) == 40, "");
#endif
_Static_assert(sizeof(A516) == 6, "");
_Static_assert(_Alignof(A516) == 1, "");
_Static_assert(sizeof(struct A516_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A516_extra_packed) == 1, "");
_Static_assert(sizeof(struct A516_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_size) == 8, "");
_Static_assert(_Alignof(struct A516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A516,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A516,e) == 40, "");
#endif
_Static_assert(sizeof(A517) == 6, "");
_Static_assert(_Alignof(A517) == 1, "");
_Static_assert(sizeof(struct A517_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A517_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A517_extra_packed) == 1, "");
_Static_assert(sizeof(struct A517_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_size) == 8, "");
_Static_assert(_Alignof(struct A517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A517,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A517,e) == 40, "");
#endif
_Static_assert(sizeof(A518) == 6, "");
_Static_assert(_Alignof(A518) == 1, "");
_Static_assert(sizeof(struct A518_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A518_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A518_extra_packed) == 1, "");
_Static_assert(sizeof(struct A518_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_size) == 8, "");
_Static_assert(_Alignof(struct A518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A518,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A518,e) == 40, "");
#endif
_Static_assert(sizeof(A519) == 6, "");
_Static_assert(_Alignof(A519) == 1, "");
_Static_assert(sizeof(struct A519_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A519_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A519_extra_packed) == 1, "");
_Static_assert(sizeof(struct A519_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_size) == 8, "");
_Static_assert(_Alignof(struct A519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A519,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A519,e) == 40, "");
#endif
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 2, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B000,e) == 0, "");
#endif
_Static_assert(sizeof(B001) == 1, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 3, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B001,e) == 0, "");
#endif
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 2, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B002,e) == 0, "");
#endif
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 4, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B003,e) == 0, "");
#endif
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 4, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B004,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B004,e) == 0, "");
#endif
_Static_assert(sizeof(B005) == 1, "");
_Static_assert(_Alignof(B005) == 1, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 3, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B005,e) == 0, "");
#endif
_Static_assert(sizeof(B006) == 1, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 3, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B006,e) == 0, "");
#endif
_Static_assert(sizeof(B007) == 1, "");
_Static_assert(_Alignof(B007) == 1, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 3, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B007,e) == 0, "");
#endif
_Static_assert(sizeof(B008) == 1, "");
_Static_assert(_Alignof(B008) == 1, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 3, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B008,e) == 0, "");
#endif
_Static_assert(sizeof(B009) == 1, "");
_Static_assert(_Alignof(B009) == 1, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 3, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B009,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B009,e) == 0, "");
#endif
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 2, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B010,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B010,e) == 0, "");
#endif
_Static_assert(sizeof(B011) == 1, "");
_Static_assert(_Alignof(B011) == 1, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 3, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B011,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B011,e) == 0, "");
#endif
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 2, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B012,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B012,e) == 0, "");
#endif
_Static_assert(sizeof(B013) == 4, "");
_Static_assert(_Alignof(B013) == 4, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B013_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 6, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B013,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B013,e) == 0, "");
#endif
_Static_assert(sizeof(B014) == 4, "");
_Static_assert(_Alignof(B014) == 4, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B014_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 6, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B014,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B014,e) == 0, "");
#endif
_Static_assert(sizeof(B015) == 1, "");
_Static_assert(_Alignof(B015) == 1, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 3, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B015,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B015,e) == 0, "");
#endif
_Static_assert(sizeof(B016) == 1, "");
_Static_assert(_Alignof(B016) == 1, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 3, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B016,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B016,e) == 0, "");
#endif
_Static_assert(sizeof(B017) == 1, "");
_Static_assert(_Alignof(B017) == 1, "");
_Static_assert(sizeof(struct B017_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B017_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B017_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B017_extra_packed) == 1, "");
_Static_assert(sizeof(struct B017_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B017_extra_size) == 3, "");
_Static_assert(_Alignof(struct B017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B017,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B017,e) == 0, "");
#endif
_Static_assert(sizeof(B018) == 1, "");
_Static_assert(_Alignof(B018) == 1, "");
_Static_assert(sizeof(struct B018_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B018_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B018_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B018_extra_packed) == 1, "");
_Static_assert(sizeof(struct B018_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B018_extra_size) == 3, "");
_Static_assert(_Alignof(struct B018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B018,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B018,e) == 0, "");
#endif
_Static_assert(sizeof(B019) == 1, "");
_Static_assert(_Alignof(B019) == 1, "");
_Static_assert(sizeof(struct B019_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B019_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B019_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B019_extra_packed) == 1, "");
_Static_assert(sizeof(struct B019_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B019_extra_size) == 3, "");
_Static_assert(_Alignof(struct B019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B019,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B019,e) == 0, "");
#endif
_Static_assert(sizeof(B100) == 4, "");
_Static_assert(_Alignof(B100) == 4, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 6, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B100,e) == 0, "");
#endif
_Static_assert(sizeof(B101) == 1, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 3, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B101,e) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B102,e) == 0, "");
#endif
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B103,e) == 0, "");
#endif
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 4, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B104,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B104,e) == 0, "");
#endif
_Static_assert(sizeof(B105) == 1, "");
_Static_assert(_Alignof(B105) == 1, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 3, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B105,e) == 0, "");
#endif
_Static_assert(sizeof(B106) == 1, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 3, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B106,e) == 0, "");
#endif
_Static_assert(sizeof(B107) == 1, "");
_Static_assert(_Alignof(B107) == 1, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 3, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B107,e) == 0, "");
#endif
_Static_assert(sizeof(B108) == 1, "");
_Static_assert(_Alignof(B108) == 1, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 3, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B108,e) == 0, "");
#endif
_Static_assert(sizeof(B109) == 1, "");
_Static_assert(_Alignof(B109) == 1, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 3, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B109,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B109,e) == 0, "");
#endif
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 4, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B110,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B110,e) == 0, "");
#endif
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 1, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B111,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B111,e) == 0, "");
#endif
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 2, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B112,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B112,e) == 0, "");
#endif
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B113,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B113,e) == 0, "");
#endif
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 4, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B114,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B114,e) == 0, "");
#endif
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 1, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B115,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B115,e) == 0, "");
#endif
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 1, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B116,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B116,e) == 0, "");
#endif
_Static_assert(sizeof(B117) == 4, "");
_Static_assert(_Alignof(B117) == 1, "");
_Static_assert(sizeof(struct B117_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B117_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B117_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B117_extra_packed) == 1, "");
_Static_assert(sizeof(struct B117_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B117_extra_size) == 6, "");
_Static_assert(_Alignof(struct B117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B117,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B117,e) == 0, "");
#endif
_Static_assert(sizeof(B118) == 4, "");
_Static_assert(_Alignof(B118) == 1, "");
_Static_assert(sizeof(struct B118_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B118_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B118_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B118_extra_packed) == 1, "");
_Static_assert(sizeof(struct B118_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B118_extra_size) == 6, "");
_Static_assert(_Alignof(struct B118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B118,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B118,e) == 0, "");
#endif
_Static_assert(sizeof(B119) == 4, "");
_Static_assert(_Alignof(B119) == 1, "");
_Static_assert(sizeof(struct B119_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B119_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B119_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B119_extra_packed) == 1, "");
_Static_assert(sizeof(struct B119_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B119_extra_size) == 6, "");
_Static_assert(_Alignof(struct B119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B119,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B119,e) == 0, "");
#endif
_Static_assert(sizeof(B200) == 1, "");
_Static_assert(_Alignof(B200) == 1, "");
_Static_assert(sizeof(struct B200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B200_extra_packed) == 1, "");
_Static_assert(sizeof(struct B200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_size) == 3, "");
_Static_assert(_Alignof(struct B200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B200,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B200,e) == 0, "");
#endif
_Static_assert(sizeof(B201) == 1, "");
_Static_assert(_Alignof(B201) == 1, "");
_Static_assert(sizeof(struct B201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B201_extra_packed) == 1, "");
_Static_assert(sizeof(struct B201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_size) == 3, "");
_Static_assert(_Alignof(struct B201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B201,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B201,e) == 0, "");
#endif
_Static_assert(sizeof(B202) == 1, "");
_Static_assert(_Alignof(B202) == 1, "");
_Static_assert(sizeof(struct B202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B202_extra_packed) == 1, "");
_Static_assert(sizeof(struct B202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_size) == 3, "");
_Static_assert(_Alignof(struct B202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B202,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B202,e) == 0, "");
#endif
_Static_assert(sizeof(B203) == 1, "");
_Static_assert(_Alignof(B203) == 1, "");
_Static_assert(sizeof(struct B203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B203_extra_packed) == 1, "");
_Static_assert(sizeof(struct B203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_size) == 3, "");
_Static_assert(_Alignof(struct B203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B203,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B203,e) == 0, "");
#endif
_Static_assert(sizeof(B204) == 1, "");
_Static_assert(_Alignof(B204) == 1, "");
_Static_assert(sizeof(struct B204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B204_extra_packed) == 1, "");
_Static_assert(sizeof(struct B204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_size) == 3, "");
_Static_assert(_Alignof(struct B204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B204,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B204,e) == 0, "");
#endif
_Static_assert(sizeof(B205) == 1, "");
_Static_assert(_Alignof(B205) == 1, "");
_Static_assert(sizeof(struct B205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B205_extra_packed) == 1, "");
_Static_assert(sizeof(struct B205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_size) == 3, "");
_Static_assert(_Alignof(struct B205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B205,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B205,e) == 0, "");
#endif
_Static_assert(sizeof(B206) == 1, "");
_Static_assert(_Alignof(B206) == 1, "");
_Static_assert(sizeof(struct B206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B206_extra_packed) == 1, "");
_Static_assert(sizeof(struct B206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_size) == 3, "");
_Static_assert(_Alignof(struct B206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B206,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B206,e) == 0, "");
#endif
_Static_assert(sizeof(B207) == 1, "");
_Static_assert(_Alignof(B207) == 1, "");
_Static_assert(sizeof(struct B207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B207_extra_packed) == 1, "");
_Static_assert(sizeof(struct B207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_size) == 3, "");
_Static_assert(_Alignof(struct B207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B207,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B207,e) == 0, "");
#endif
_Static_assert(sizeof(B208) == 1, "");
_Static_assert(_Alignof(B208) == 1, "");
_Static_assert(sizeof(struct B208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B208_extra_packed) == 1, "");
_Static_assert(sizeof(struct B208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_size) == 3, "");
_Static_assert(_Alignof(struct B208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B208,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B208,e) == 0, "");
#endif
_Static_assert(sizeof(B209) == 1, "");
_Static_assert(_Alignof(B209) == 1, "");
_Static_assert(sizeof(struct B209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B209_extra_packed) == 1, "");
_Static_assert(sizeof(struct B209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_size) == 3, "");
_Static_assert(_Alignof(struct B209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B209,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B209,e) == 0, "");
#endif
_Static_assert(sizeof(B210) == 1, "");
_Static_assert(_Alignof(B210) == 1, "");
_Static_assert(sizeof(struct B210_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B210_extra_packed) == 1, "");
_Static_assert(sizeof(struct B210_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_size) == 3, "");
_Static_assert(_Alignof(struct B210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B210,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B210,e) == 0, "");
#endif
_Static_assert(sizeof(B211) == 1, "");
_Static_assert(_Alignof(B211) == 1, "");
_Static_assert(sizeof(struct B211_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B211_extra_packed) == 1, "");
_Static_assert(sizeof(struct B211_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_size) == 3, "");
_Static_assert(_Alignof(struct B211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B211,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B211,e) == 0, "");
#endif
_Static_assert(sizeof(B212) == 1, "");
_Static_assert(_Alignof(B212) == 1, "");
_Static_assert(sizeof(struct B212_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B212_extra_packed) == 1, "");
_Static_assert(sizeof(struct B212_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_size) == 3, "");
_Static_assert(_Alignof(struct B212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B212,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B212,e) == 0, "");
#endif
_Static_assert(sizeof(B213) == 1, "");
_Static_assert(_Alignof(B213) == 1, "");
_Static_assert(sizeof(struct B213_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B213_extra_packed) == 1, "");
_Static_assert(sizeof(struct B213_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_size) == 3, "");
_Static_assert(_Alignof(struct B213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B213,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B213,e) == 0, "");
#endif
_Static_assert(sizeof(B214) == 1, "");
_Static_assert(_Alignof(B214) == 1, "");
_Static_assert(sizeof(struct B214_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B214_extra_packed) == 1, "");
_Static_assert(sizeof(struct B214_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_size) == 3, "");
_Static_assert(_Alignof(struct B214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B214,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B214,e) == 0, "");
#endif
_Static_assert(sizeof(B215) == 1, "");
_Static_assert(_Alignof(B215) == 1, "");
_Static_assert(sizeof(struct B215_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B215_extra_packed) == 1, "");
_Static_assert(sizeof(struct B215_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_size) == 3, "");
_Static_assert(_Alignof(struct B215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B215,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B215,e) == 0, "");
#endif
_Static_assert(sizeof(B216) == 1, "");
_Static_assert(_Alignof(B216) == 1, "");
_Static_assert(sizeof(struct B216_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B216_extra_packed) == 1, "");
_Static_assert(sizeof(struct B216_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_size) == 3, "");
_Static_assert(_Alignof(struct B216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B216,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B216,e) == 0, "");
#endif
_Static_assert(sizeof(B217) == 1, "");
_Static_assert(_Alignof(B217) == 1, "");
_Static_assert(sizeof(struct B217_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B217_extra_packed) == 1, "");
_Static_assert(sizeof(struct B217_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_size) == 3, "");
_Static_assert(_Alignof(struct B217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B217,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B217,e) == 0, "");
#endif
_Static_assert(sizeof(B218) == 1, "");
_Static_assert(_Alignof(B218) == 1, "");
_Static_assert(sizeof(struct B218_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B218_extra_packed) == 1, "");
_Static_assert(sizeof(struct B218_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_size) == 3, "");
_Static_assert(_Alignof(struct B218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B218,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B218,e) == 0, "");
#endif
_Static_assert(sizeof(B219) == 1, "");
_Static_assert(_Alignof(B219) == 1, "");
_Static_assert(sizeof(struct B219_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B219_extra_packed) == 1, "");
_Static_assert(sizeof(struct B219_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_size) == 3, "");
_Static_assert(_Alignof(struct B219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B219,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B219,e) == 0, "");
#endif
_Static_assert(sizeof(B300) == 4, "");
_Static_assert(_Alignof(B300) == 4, "");
_Static_assert(sizeof(struct B300_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B300_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B300_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B300_extra_packed) == 1, "");
_Static_assert(sizeof(struct B300_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B300_extra_size) == 6, "");
_Static_assert(_Alignof(struct B300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B300,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B300,e) == 0, "");
#endif
_Static_assert(sizeof(B301) == 1, "");
_Static_assert(_Alignof(B301) == 1, "");
_Static_assert(sizeof(struct B301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B301_extra_packed) == 1, "");
_Static_assert(sizeof(struct B301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_size) == 3, "");
_Static_assert(_Alignof(struct B301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B301,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B301,e) == 0, "");
#endif
_Static_assert(sizeof(B302) == 2, "");
_Static_assert(_Alignof(B302) == 2, "");
_Static_assert(sizeof(struct B302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B302_extra_packed) == 1, "");
_Static_assert(sizeof(struct B302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B302_extra_size) == 4, "");
_Static_assert(_Alignof(struct B302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B302,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B302,e) == 0, "");
#endif
_Static_assert(sizeof(B303) == 4, "");
_Static_assert(_Alignof(B303) == 4, "");
_Static_assert(sizeof(struct B303_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B303_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B303_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B303_extra_packed) == 1, "");
_Static_assert(sizeof(struct B303_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B303_extra_size) == 6, "");
_Static_assert(_Alignof(struct B303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B303,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B303,e) == 0, "");
#endif
_Static_assert(sizeof(B304) == 4, "");
_Static_assert(_Alignof(B304) == 4, "");
_Static_assert(sizeof(struct B304_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B304_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B304_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B304_extra_packed) == 1, "");
_Static_assert(sizeof(struct B304_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B304_extra_size) == 6, "");
_Static_assert(_Alignof(struct B304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B304,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B304,e) == 0, "");
#endif
_Static_assert(sizeof(B305) == 1, "");
_Static_assert(_Alignof(B305) == 1, "");
_Static_assert(sizeof(struct B305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B305_extra_packed) == 1, "");
_Static_assert(sizeof(struct B305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_size) == 3, "");
_Static_assert(_Alignof(struct B305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B305,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B305,e) == 0, "");
#endif
_Static_assert(sizeof(B306) == 1, "");
_Static_assert(_Alignof(B306) == 1, "");
_Static_assert(sizeof(struct B306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B306_extra_packed) == 1, "");
_Static_assert(sizeof(struct B306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_size) == 3, "");
_Static_assert(_Alignof(struct B306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B306,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B306,e) == 0, "");
#endif
_Static_assert(sizeof(B307) == 1, "");
_Static_assert(_Alignof(B307) == 1, "");
_Static_assert(sizeof(struct B307_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B307_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B307_extra_packed) == 1, "");
_Static_assert(sizeof(struct B307_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_size) == 3, "");
_Static_assert(_Alignof(struct B307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B307,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B307,e) == 0, "");
#endif
_Static_assert(sizeof(B308) == 1, "");
_Static_assert(_Alignof(B308) == 1, "");
_Static_assert(sizeof(struct B308_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B308_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B308_extra_packed) == 1, "");
_Static_assert(sizeof(struct B308_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_size) == 3, "");
_Static_assert(_Alignof(struct B308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B308,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B308,e) == 0, "");
#endif
_Static_assert(sizeof(B309) == 1, "");
_Static_assert(_Alignof(B309) == 1, "");
_Static_assert(sizeof(struct B309_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B309_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B309_extra_packed) == 1, "");
_Static_assert(sizeof(struct B309_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_size) == 3, "");
_Static_assert(_Alignof(struct B309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B309,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B309,e) == 0, "");
#endif
_Static_assert(sizeof(B310) == 4, "");
_Static_assert(_Alignof(B310) == 4, "");
_Static_assert(sizeof(struct B310_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B310_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B310_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B310_extra_packed) == 1, "");
_Static_assert(sizeof(struct B310_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B310_extra_size) == 6, "");
_Static_assert(_Alignof(struct B310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B310,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B310,e) == 0, "");
#endif
_Static_assert(sizeof(B311) == 4, "");
_Static_assert(_Alignof(B311) == 1, "");
_Static_assert(sizeof(struct B311_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B311_extra_packed) == 1, "");
_Static_assert(sizeof(struct B311_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_size) == 6, "");
_Static_assert(_Alignof(struct B311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B311,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B311,e) == 0, "");
#endif
_Static_assert(sizeof(B312) == 4, "");
_Static_assert(_Alignof(B312) == 2, "");
_Static_assert(sizeof(struct B312_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B312_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B312_extra_packed) == 1, "");
_Static_assert(sizeof(struct B312_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B312_extra_size) == 6, "");
_Static_assert(_Alignof(struct B312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B312,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B312,e) == 0, "");
#endif
_Static_assert(sizeof(B313) == 4, "");
_Static_assert(_Alignof(B313) == 4, "");
_Static_assert(sizeof(struct B313_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B313_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B313_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B313_extra_packed) == 1, "");
_Static_assert(sizeof(struct B313_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B313_extra_size) == 6, "");
_Static_assert(_Alignof(struct B313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B313,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B313,e) == 0, "");
#endif
_Static_assert(sizeof(B314) == 4, "");
_Static_assert(_Alignof(B314) == 4, "");
_Static_assert(sizeof(struct B314_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B314_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B314_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B314_extra_packed) == 1, "");
_Static_assert(sizeof(struct B314_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B314_extra_size) == 6, "");
_Static_assert(_Alignof(struct B314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B314,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B314,e) == 0, "");
#endif
_Static_assert(sizeof(B315) == 4, "");
_Static_assert(_Alignof(B315) == 1, "");
_Static_assert(sizeof(struct B315_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B315_extra_packed) == 1, "");
_Static_assert(sizeof(struct B315_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_size) == 6, "");
_Static_assert(_Alignof(struct B315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B315,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B315,e) == 0, "");
#endif
_Static_assert(sizeof(B316) == 4, "");
_Static_assert(_Alignof(B316) == 1, "");
_Static_assert(sizeof(struct B316_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B316_extra_packed) == 1, "");
_Static_assert(sizeof(struct B316_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_size) == 6, "");
_Static_assert(_Alignof(struct B316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B316,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B316,e) == 0, "");
#endif
_Static_assert(sizeof(B317) == 4, "");
_Static_assert(_Alignof(B317) == 1, "");
_Static_assert(sizeof(struct B317_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B317_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B317_extra_packed) == 1, "");
_Static_assert(sizeof(struct B317_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_size) == 6, "");
_Static_assert(_Alignof(struct B317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B317,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B317,e) == 0, "");
#endif
_Static_assert(sizeof(B318) == 4, "");
_Static_assert(_Alignof(B318) == 1, "");
_Static_assert(sizeof(struct B318_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B318_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B318_extra_packed) == 1, "");
_Static_assert(sizeof(struct B318_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_size) == 6, "");
_Static_assert(_Alignof(struct B318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B318,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B318,e) == 0, "");
#endif
_Static_assert(sizeof(B319) == 4, "");
_Static_assert(_Alignof(B319) == 1, "");
_Static_assert(sizeof(struct B319_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B319_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B319_extra_packed) == 1, "");
_Static_assert(sizeof(struct B319_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_size) == 6, "");
_Static_assert(_Alignof(struct B319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B319,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B319,e) == 0, "");
#endif
_Static_assert(sizeof(B410) == 4, "");
_Static_assert(_Alignof(B410) == 4, "");
_Static_assert(sizeof(struct B410_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B410_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B410_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B410_extra_packed) == 1, "");
_Static_assert(sizeof(struct B410_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B410_extra_size) == 6, "");
_Static_assert(_Alignof(struct B410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B410,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B410,e) == 0, "");
#endif
_Static_assert(sizeof(B411) == 4, "");
_Static_assert(_Alignof(B411) == 1, "");
_Static_assert(sizeof(struct B411_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B411_extra_packed) == 1, "");
_Static_assert(sizeof(struct B411_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_size) == 6, "");
_Static_assert(_Alignof(struct B411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B411,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B411,e) == 0, "");
#endif
_Static_assert(sizeof(B412) == 4, "");
_Static_assert(_Alignof(B412) == 2, "");
_Static_assert(sizeof(struct B412_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B412_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B412_extra_packed) == 1, "");
_Static_assert(sizeof(struct B412_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B412_extra_size) == 6, "");
_Static_assert(_Alignof(struct B412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B412,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B412,e) == 0, "");
#endif
_Static_assert(sizeof(B413) == 4, "");
_Static_assert(_Alignof(B413) == 4, "");
_Static_assert(sizeof(struct B413_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B413_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B413_extra_packed) == 1, "");
_Static_assert(sizeof(struct B413_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B413_extra_size) == 6, "");
_Static_assert(_Alignof(struct B413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B413,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B413,e) == 0, "");
#endif
_Static_assert(sizeof(B414) == 4, "");
_Static_assert(_Alignof(B414) == 4, "");
_Static_assert(sizeof(struct B414_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B414_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B414_extra_packed) == 1, "");
_Static_assert(sizeof(struct B414_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B414_extra_size) == 6, "");
_Static_assert(_Alignof(struct B414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B414,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B414,e) == 0, "");
#endif
_Static_assert(sizeof(B415) == 4, "");
_Static_assert(_Alignof(B415) == 1, "");
_Static_assert(sizeof(struct B415_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B415_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B415_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B415_extra_packed) == 1, "");
_Static_assert(sizeof(struct B415_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B415_extra_size) == 6, "");
_Static_assert(_Alignof(struct B415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B415,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B415,e) == 0, "");
#endif
_Static_assert(sizeof(B416) == 4, "");
_Static_assert(_Alignof(B416) == 1, "");
_Static_assert(sizeof(struct B416_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B416_extra_packed) == 1, "");
_Static_assert(sizeof(struct B416_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_size) == 6, "");
_Static_assert(_Alignof(struct B416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B416,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B416,e) == 0, "");
#endif
_Static_assert(sizeof(B417) == 4, "");
_Static_assert(_Alignof(B417) == 1, "");
_Static_assert(sizeof(struct B417_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B417_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B417_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B417_extra_packed) == 1, "");
_Static_assert(sizeof(struct B417_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B417_extra_size) == 6, "");
_Static_assert(_Alignof(struct B417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B417,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B417,e) == 0, "");
#endif
_Static_assert(sizeof(B418) == 4, "");
_Static_assert(_Alignof(B418) == 1, "");
_Static_assert(sizeof(struct B418_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B418_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B418_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B418_extra_packed) == 1, "");
_Static_assert(sizeof(struct B418_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B418_extra_size) == 6, "");
_Static_assert(_Alignof(struct B418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B418,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B418,e) == 0, "");
#endif
_Static_assert(sizeof(B419) == 4, "");
_Static_assert(_Alignof(B419) == 1, "");
_Static_assert(sizeof(struct B419_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B419_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B419_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B419_extra_packed) == 1, "");
_Static_assert(sizeof(struct B419_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B419_extra_size) == 6, "");
_Static_assert(_Alignof(struct B419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B419,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B419,e) == 0, "");
#endif
_Static_assert(sizeof(B510) == 4, "");
_Static_assert(_Alignof(B510) == 4, "");
_Static_assert(sizeof(struct B510_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B510_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B510_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B510_extra_packed) == 1, "");
_Static_assert(sizeof(struct B510_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B510_extra_size) == 6, "");
_Static_assert(_Alignof(struct B510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B510,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B510,e) == 0, "");
#endif
_Static_assert(sizeof(B511) == 4, "");
_Static_assert(_Alignof(B511) == 1, "");
_Static_assert(sizeof(struct B511_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B511_extra_packed) == 1, "");
_Static_assert(sizeof(struct B511_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_size) == 6, "");
_Static_assert(_Alignof(struct B511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B511,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B511,e) == 0, "");
#endif
_Static_assert(sizeof(B512) == 4, "");
_Static_assert(_Alignof(B512) == 2, "");
_Static_assert(sizeof(struct B512_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B512_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B512_extra_packed) == 1, "");
_Static_assert(sizeof(struct B512_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B512_extra_size) == 6, "");
_Static_assert(_Alignof(struct B512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B512,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B512,e) == 0, "");
#endif
_Static_assert(sizeof(B513) == 4, "");
_Static_assert(_Alignof(B513) == 4, "");
_Static_assert(sizeof(struct B513_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B513_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B513_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B513_extra_packed) == 1, "");
_Static_assert(sizeof(struct B513_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B513_extra_size) == 6, "");
_Static_assert(_Alignof(struct B513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B513,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B513,e) == 0, "");
#endif
_Static_assert(sizeof(B514) == 4, "");
_Static_assert(_Alignof(B514) == 4, "");
_Static_assert(sizeof(struct B514_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B514_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B514_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B514_extra_packed) == 1, "");
_Static_assert(sizeof(struct B514_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B514_extra_size) == 6, "");
_Static_assert(_Alignof(struct B514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B514,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B514,e) == 0, "");
#endif
_Static_assert(sizeof(B515) == 4, "");
_Static_assert(_Alignof(B515) == 1, "");
_Static_assert(sizeof(struct B515_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B515_extra_packed) == 1, "");
_Static_assert(sizeof(struct B515_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_size) == 6, "");
_Static_assert(_Alignof(struct B515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B515,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B515,e) == 0, "");
#endif
_Static_assert(sizeof(B516) == 4, "");
_Static_assert(_Alignof(B516) == 1, "");
_Static_assert(sizeof(struct B516_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B516_extra_packed) == 1, "");
_Static_assert(sizeof(struct B516_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_size) == 6, "");
_Static_assert(_Alignof(struct B516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B516,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B516,e) == 0, "");
#endif
_Static_assert(sizeof(B517) == 4, "");
_Static_assert(_Alignof(B517) == 1, "");
_Static_assert(sizeof(struct B517_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B517_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B517_extra_packed) == 1, "");
_Static_assert(sizeof(struct B517_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_size) == 6, "");
_Static_assert(_Alignof(struct B517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B517,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B517,e) == 0, "");
#endif
_Static_assert(sizeof(B518) == 4, "");
_Static_assert(_Alignof(B518) == 1, "");
_Static_assert(sizeof(struct B518_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B518_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B518_extra_packed) == 1, "");
_Static_assert(sizeof(struct B518_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_size) == 6, "");
_Static_assert(_Alignof(struct B518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B518,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B518,e) == 0, "");
#endif
_Static_assert(sizeof(B519) == 4, "");
_Static_assert(_Alignof(B519) == 1, "");
_Static_assert(sizeof(struct B519_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B519_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B519_extra_packed) == 1, "");
_Static_assert(sizeof(struct B519_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_size) == 6, "");
_Static_assert(_Alignof(struct B519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B519,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B519,e) == 0, "");
#endif
// MAPPING|EIGHT|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(EIGHT)
_Static_assert(sizeof(A000) == 4, "");
_Static_assert(_Alignof(A000) == 2, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 6, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A000,e) == 17, "");
#endif
_Static_assert(sizeof(A001) == 1, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 3, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A001,e) == 2, "");
#endif
_Static_assert(sizeof(A002) == 2, "");
_Static_assert(_Alignof(A002) == 2, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 4, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A002,e) == 2, "");
#endif
_Static_assert(sizeof(A003) == 8, "");
_Static_assert(_Alignof(A003) == 4, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A003_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 10, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A003,e) == 33, "");
#endif
_Static_assert(sizeof(A004) == 8, "");
_Static_assert(_Alignof(A004) == 4, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A004_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 10, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A004,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A004,e) == 33, "");
#endif
_Static_assert(sizeof(A005) == 4, "");
_Static_assert(_Alignof(A005) == 2, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A005_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 6, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A005,e) == 17, "");
#endif
_Static_assert(sizeof(A006) == 1, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 3, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A006,e) == 2, "");
#endif
_Static_assert(sizeof(A007) == 2, "");
_Static_assert(_Alignof(A007) == 2, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 4, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A007,e) == 2, "");
#endif
_Static_assert(sizeof(A008) == 8, "");
_Static_assert(_Alignof(A008) == 4, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A008_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 10, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A008,e) == 33, "");
#endif
_Static_assert(sizeof(A009) == 8, "");
_Static_assert(_Alignof(A009) == 4, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A009_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 10, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A009,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A009,e) == 33, "");
#endif
_Static_assert(sizeof(A010) == 4, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 6, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A010,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A010,e) == 24, "");
#endif
_Static_assert(sizeof(A011) == 2, "");
_Static_assert(_Alignof(A011) == 1, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 4, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A011,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A011,e) == 9, "");
#endif
_Static_assert(sizeof(A012) == 2, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 4, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A012,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A012,e) == 9, "");
#endif
_Static_assert(sizeof(A013) == 8, "");
_Static_assert(_Alignof(A013) == 4, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A013_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 10, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A013,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A013,e) == 40, "");
#endif
_Static_assert(sizeof(A014) == 8, "");
_Static_assert(_Alignof(A014) == 4, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A014_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 10, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A014,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A014,e) == 40, "");
#endif
_Static_assert(sizeof(A015) == 4, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 6, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A015,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A015,e) == 24, "");
#endif
_Static_assert(sizeof(A016) == 2, "");
_Static_assert(_Alignof(A016) == 1, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 4, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A016,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A016,e) == 9, "");
#endif
_Static_assert(sizeof(A017) == 2, "");
_Static_assert(_Alignof(A017) == 2, "");
_Static_assert(sizeof(struct A017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A017_extra_packed) == 1, "");
_Static_assert(sizeof(struct A017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A017_extra_size) == 4, "");
_Static_assert(_Alignof(struct A017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A017,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A017,e) == 9, "");
#endif
_Static_assert(sizeof(A018) == 8, "");
_Static_assert(_Alignof(A018) == 4, "");
_Static_assert(sizeof(struct A018_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A018_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A018_extra_packed) == 1, "");
_Static_assert(sizeof(struct A018_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A018_extra_size) == 10, "");
_Static_assert(_Alignof(struct A018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A018,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A018,e) == 40, "");
#endif
_Static_assert(sizeof(A019) == 8, "");
_Static_assert(_Alignof(A019) == 4, "");
_Static_assert(sizeof(struct A019_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A019_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A019_extra_packed) == 1, "");
_Static_assert(sizeof(struct A019_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A019_extra_size) == 10, "");
_Static_assert(_Alignof(struct A019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A019,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A019,e) == 40, "");
#endif
_Static_assert(sizeof(A100) == 4, "");
_Static_assert(_Alignof(A100) == 2, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 6, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A100,e) == 17, "");
#endif
_Static_assert(sizeof(A101) == 1, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 3, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A101,e) == 3, "");
#endif
_Static_assert(sizeof(A102) == 2, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 4, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A102,e) == 3, "");
#endif
_Static_assert(sizeof(A103) == 8, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 10, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A103,e) == 33, "");
#endif
_Static_assert(sizeof(A104) == 8, "");
_Static_assert(_Alignof(A104) == 4, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A104_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 10, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A104,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A104,e) == 33, "");
#endif
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A105,e) == 17, "");
#endif
_Static_assert(sizeof(A106) == 1, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 3, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A106,e) == 3, "");
#endif
_Static_assert(sizeof(A107) == 2, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 4, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A107,e) == 3, "");
#endif
_Static_assert(sizeof(A108) == 8, "");
_Static_assert(_Alignof(A108) == 4, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A108_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 10, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A108,e) == 33, "");
#endif
_Static_assert(sizeof(A109) == 8, "");
_Static_assert(_Alignof(A109) == 4, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A109_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 10, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A109,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A109,e) == 33, "");
#endif
_Static_assert(sizeof(A110) == 6, "");
_Static_assert(_Alignof(A110) == 2, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A110_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 8, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A110,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A110,e) == 47, "");
#endif
_Static_assert(sizeof(A111) == 5, "");
_Static_assert(_Alignof(A111) == 1, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 7, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A111,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A111,e) == 33, "");
#endif
_Static_assert(sizeof(A112) == 6, "");
_Static_assert(_Alignof(A112) == 2, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A112_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 8, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A112,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A112,e) == 33, "");
#endif
_Static_assert(sizeof(A113) == 8, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 10, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A113,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A113,e) == 63, "");
#endif
_Static_assert(sizeof(A114) == 8, "");
_Static_assert(_Alignof(A114) == 4, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A114_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 10, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A114,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A114,e) == 63, "");
#endif
_Static_assert(sizeof(A115) == 6, "");
_Static_assert(_Alignof(A115) == 2, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A115_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 8, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A115,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A115,e) == 47, "");
#endif
_Static_assert(sizeof(A116) == 5, "");
_Static_assert(_Alignof(A116) == 1, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 7, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A116,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A116,e) == 33, "");
#endif
_Static_assert(sizeof(A117) == 6, "");
_Static_assert(_Alignof(A117) == 2, "");
_Static_assert(sizeof(struct A117_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A117_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A117_extra_packed) == 1, "");
_Static_assert(sizeof(struct A117_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A117_extra_size) == 8, "");
_Static_assert(_Alignof(struct A117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A117,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A117,e) == 33, "");
#endif
_Static_assert(sizeof(A118) == 8, "");
_Static_assert(_Alignof(A118) == 4, "");
_Static_assert(sizeof(struct A118_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A118_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A118_extra_packed) == 1, "");
_Static_assert(sizeof(struct A118_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A118_extra_size) == 10, "");
_Static_assert(_Alignof(struct A118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A118,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A118,e) == 63, "");
#endif
_Static_assert(sizeof(A119) == 8, "");
_Static_assert(_Alignof(A119) == 4, "");
_Static_assert(sizeof(struct A119_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A119_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A119_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A119_extra_packed) == 1, "");
_Static_assert(sizeof(struct A119_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A119_extra_size) == 10, "");
_Static_assert(_Alignof(struct A119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A119,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A119,e) == 63, "");
#endif
_Static_assert(sizeof(A200) == 1, "");
_Static_assert(_Alignof(A200) == 1, "");
_Static_assert(sizeof(struct A200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A200_extra_packed) == 1, "");
_Static_assert(sizeof(struct A200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A200_extra_size) == 3, "");
_Static_assert(_Alignof(struct A200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A200,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A200,e) == 2, "");
#endif
_Static_assert(sizeof(A201) == 1, "");
_Static_assert(_Alignof(A201) == 1, "");
_Static_assert(sizeof(struct A201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A201_extra_packed) == 1, "");
_Static_assert(sizeof(struct A201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A201_extra_size) == 3, "");
_Static_assert(_Alignof(struct A201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A201,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A201,e) == 2, "");
#endif
_Static_assert(sizeof(A202) == 1, "");
_Static_assert(_Alignof(A202) == 1, "");
_Static_assert(sizeof(struct A202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A202_extra_packed) == 1, "");
_Static_assert(sizeof(struct A202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A202_extra_size) == 3, "");
_Static_assert(_Alignof(struct A202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A202,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A202,e) == 2, "");
#endif
_Static_assert(sizeof(A203) == 1, "");
_Static_assert(_Alignof(A203) == 1, "");
_Static_assert(sizeof(struct A203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A203_extra_packed) == 1, "");
_Static_assert(sizeof(struct A203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A203_extra_size) == 3, "");
_Static_assert(_Alignof(struct A203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A203,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A203,e) == 2, "");
#endif
_Static_assert(sizeof(A204) == 1, "");
_Static_assert(_Alignof(A204) == 1, "");
_Static_assert(sizeof(struct A204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A204_extra_packed) == 1, "");
_Static_assert(sizeof(struct A204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A204_extra_size) == 3, "");
_Static_assert(_Alignof(struct A204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A204,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A204,e) == 2, "");
#endif
_Static_assert(sizeof(A205) == 1, "");
_Static_assert(_Alignof(A205) == 1, "");
_Static_assert(sizeof(struct A205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A205_extra_packed) == 1, "");
_Static_assert(sizeof(struct A205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A205_extra_size) == 3, "");
_Static_assert(_Alignof(struct A205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A205,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A205,e) == 2, "");
#endif
_Static_assert(sizeof(A206) == 1, "");
_Static_assert(_Alignof(A206) == 1, "");
_Static_assert(sizeof(struct A206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A206_extra_packed) == 1, "");
_Static_assert(sizeof(struct A206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A206_extra_size) == 3, "");
_Static_assert(_Alignof(struct A206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A206,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A206,e) == 2, "");
#endif
_Static_assert(sizeof(A207) == 1, "");
_Static_assert(_Alignof(A207) == 1, "");
_Static_assert(sizeof(struct A207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A207_extra_packed) == 1, "");
_Static_assert(sizeof(struct A207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A207_extra_size) == 3, "");
_Static_assert(_Alignof(struct A207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A207,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A207,e) == 2, "");
#endif
_Static_assert(sizeof(A208) == 1, "");
_Static_assert(_Alignof(A208) == 1, "");
_Static_assert(sizeof(struct A208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A208_extra_packed) == 1, "");
_Static_assert(sizeof(struct A208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A208_extra_size) == 3, "");
_Static_assert(_Alignof(struct A208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A208,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A208,e) == 2, "");
#endif
_Static_assert(sizeof(A209) == 1, "");
_Static_assert(_Alignof(A209) == 1, "");
_Static_assert(sizeof(struct A209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A209_extra_packed) == 1, "");
_Static_assert(sizeof(struct A209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A209_extra_size) == 3, "");
_Static_assert(_Alignof(struct A209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A209,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A209,e) == 2, "");
#endif
_Static_assert(sizeof(A210) == 3, "");
_Static_assert(_Alignof(A210) == 1, "");
_Static_assert(sizeof(struct A210_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A210_extra_packed) == 1, "");
_Static_assert(sizeof(struct A210_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A210_extra_size) == 5, "");
_Static_assert(_Alignof(struct A210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A210,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(A210,e) == 16, "");
#endif
_Static_assert(sizeof(A211) == 2, "");
_Static_assert(_Alignof(A211) == 1, "");
_Static_assert(sizeof(struct A211_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A211_extra_packed) == 1, "");
_Static_assert(sizeof(struct A211_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A211_extra_size) == 4, "");
_Static_assert(_Alignof(struct A211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A211,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A211,e) == 9, "");
#endif
_Static_assert(sizeof(A212) == 2, "");
_Static_assert(_Alignof(A212) == 1, "");
_Static_assert(sizeof(struct A212_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A212_extra_packed) == 1, "");
_Static_assert(sizeof(struct A212_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A212_extra_size) == 4, "");
_Static_assert(_Alignof(struct A212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A212,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A212,e) == 9, "");
#endif
_Static_assert(sizeof(A213) == 2, "");
_Static_assert(_Alignof(A213) == 1, "");
_Static_assert(sizeof(struct A213_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A213_extra_packed) == 1, "");
_Static_assert(sizeof(struct A213_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A213_extra_size) == 4, "");
_Static_assert(_Alignof(struct A213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A213,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A213,e) == 9, "");
#endif
_Static_assert(sizeof(A214) == 2, "");
_Static_assert(_Alignof(A214) == 1, "");
_Static_assert(sizeof(struct A214_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A214_extra_packed) == 1, "");
_Static_assert(sizeof(struct A214_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A214_extra_size) == 4, "");
_Static_assert(_Alignof(struct A214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A214,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A214,e) == 9, "");
#endif
_Static_assert(sizeof(A215) == 2, "");
_Static_assert(_Alignof(A215) == 1, "");
_Static_assert(sizeof(struct A215_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A215_extra_packed) == 1, "");
_Static_assert(sizeof(struct A215_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A215_extra_size) == 4, "");
_Static_assert(_Alignof(struct A215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A215,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A215,e) == 9, "");
#endif
_Static_assert(sizeof(A216) == 2, "");
_Static_assert(_Alignof(A216) == 1, "");
_Static_assert(sizeof(struct A216_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A216_extra_packed) == 1, "");
_Static_assert(sizeof(struct A216_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A216_extra_size) == 4, "");
_Static_assert(_Alignof(struct A216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A216,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A216,e) == 9, "");
#endif
_Static_assert(sizeof(A217) == 2, "");
_Static_assert(_Alignof(A217) == 1, "");
_Static_assert(sizeof(struct A217_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A217_extra_packed) == 1, "");
_Static_assert(sizeof(struct A217_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A217_extra_size) == 4, "");
_Static_assert(_Alignof(struct A217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A217,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A217,e) == 9, "");
#endif
_Static_assert(sizeof(A218) == 2, "");
_Static_assert(_Alignof(A218) == 1, "");
_Static_assert(sizeof(struct A218_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A218_extra_packed) == 1, "");
_Static_assert(sizeof(struct A218_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A218_extra_size) == 4, "");
_Static_assert(_Alignof(struct A218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A218,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A218,e) == 9, "");
#endif
_Static_assert(sizeof(A219) == 2, "");
_Static_assert(_Alignof(A219) == 1, "");
_Static_assert(sizeof(struct A219_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A219_extra_packed) == 1, "");
_Static_assert(sizeof(struct A219_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A219_extra_size) == 4, "");
_Static_assert(_Alignof(struct A219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A219,d) == 1, "");
_Static_assert(__builtin_bitoffsetof(A219,e) == 9, "");
#endif
_Static_assert(sizeof(A300) == 2, "");
_Static_assert(_Alignof(A300) == 2, "");
_Static_assert(sizeof(struct A300_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A300_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A300_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A300_extra_packed) == 1, "");
_Static_assert(sizeof(struct A300_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A300_extra_size) == 4, "");
_Static_assert(_Alignof(struct A300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A300,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A300,e) == 3, "");
#endif
_Static_assert(sizeof(A301) == 1, "");
_Static_assert(_Alignof(A301) == 1, "");
_Static_assert(sizeof(struct A301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A301_extra_packed) == 1, "");
_Static_assert(sizeof(struct A301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A301_extra_size) == 3, "");
_Static_assert(_Alignof(struct A301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A301,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A301,e) == 3, "");
#endif
_Static_assert(sizeof(A302) == 2, "");
_Static_assert(_Alignof(A302) == 2, "");
_Static_assert(sizeof(struct A302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A302_extra_packed) == 1, "");
_Static_assert(sizeof(struct A302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A302_extra_size) == 4, "");
_Static_assert(_Alignof(struct A302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A302,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A302,e) == 3, "");
#endif
_Static_assert(sizeof(A303) == 2, "");
_Static_assert(_Alignof(A303) == 2, "");
_Static_assert(sizeof(struct A303_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A303_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A303_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A303_extra_packed) == 1, "");
_Static_assert(sizeof(struct A303_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A303_extra_size) == 4, "");
_Static_assert(_Alignof(struct A303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A303,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A303,e) == 3, "");
#endif
_Static_assert(sizeof(A304) == 2, "");
_Static_assert(_Alignof(A304) == 2, "");
_Static_assert(sizeof(struct A304_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A304_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A304_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A304_extra_packed) == 1, "");
_Static_assert(sizeof(struct A304_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A304_extra_size) == 4, "");
_Static_assert(_Alignof(struct A304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A304,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A304,e) == 3, "");
#endif
_Static_assert(sizeof(A305) == 1, "");
_Static_assert(_Alignof(A305) == 1, "");
_Static_assert(sizeof(struct A305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A305_extra_packed) == 1, "");
_Static_assert(sizeof(struct A305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A305_extra_size) == 3, "");
_Static_assert(_Alignof(struct A305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A305,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A305,e) == 3, "");
#endif
_Static_assert(sizeof(A306) == 1, "");
_Static_assert(_Alignof(A306) == 1, "");
_Static_assert(sizeof(struct A306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A306_extra_packed) == 1, "");
_Static_assert(sizeof(struct A306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A306_extra_size) == 3, "");
_Static_assert(_Alignof(struct A306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A306,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A306,e) == 3, "");
#endif
_Static_assert(sizeof(A307) == 2, "");
_Static_assert(_Alignof(A307) == 2, "");
_Static_assert(sizeof(struct A307_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A307_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A307_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A307_extra_packed) == 1, "");
_Static_assert(sizeof(struct A307_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A307_extra_size) == 4, "");
_Static_assert(_Alignof(struct A307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A307,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A307,e) == 3, "");
#endif
_Static_assert(sizeof(A308) == 2, "");
_Static_assert(_Alignof(A308) == 2, "");
_Static_assert(sizeof(struct A308_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A308_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A308_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A308_extra_packed) == 1, "");
_Static_assert(sizeof(struct A308_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A308_extra_size) == 4, "");
_Static_assert(_Alignof(struct A308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A308,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A308,e) == 3, "");
#endif
_Static_assert(sizeof(A309) == 2, "");
_Static_assert(_Alignof(A309) == 2, "");
_Static_assert(sizeof(struct A309_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A309_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A309_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A309_extra_packed) == 1, "");
_Static_assert(sizeof(struct A309_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A309_extra_size) == 4, "");
_Static_assert(_Alignof(struct A309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A309,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A309,e) == 3, "");
#endif
_Static_assert(sizeof(A310) == 6, "");
_Static_assert(_Alignof(A310) == 2, "");
_Static_assert(sizeof(struct A310_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A310_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A310_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A310_extra_packed) == 1, "");
_Static_assert(sizeof(struct A310_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A310_extra_size) == 8, "");
_Static_assert(_Alignof(struct A310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A310,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A310,e) == 47, "");
#endif
_Static_assert(sizeof(A311) == 5, "");
_Static_assert(_Alignof(A311) == 1, "");
_Static_assert(sizeof(struct A311_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A311_extra_packed) == 1, "");
_Static_assert(sizeof(struct A311_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A311_extra_size) == 7, "");
_Static_assert(_Alignof(struct A311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A311,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A311,e) == 33, "");
#endif
_Static_assert(sizeof(A312) == 6, "");
_Static_assert(_Alignof(A312) == 2, "");
_Static_assert(sizeof(struct A312_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A312_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A312_extra_packed) == 1, "");
_Static_assert(sizeof(struct A312_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A312_extra_size) == 8, "");
_Static_assert(_Alignof(struct A312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A312,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A312,e) == 33, "");
#endif
_Static_assert(sizeof(A313) == 6, "");
_Static_assert(_Alignof(A313) == 2, "");
_Static_assert(sizeof(struct A313_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A313_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A313_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A313_extra_packed) == 1, "");
_Static_assert(sizeof(struct A313_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A313_extra_size) == 8, "");
_Static_assert(_Alignof(struct A313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A313,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A313,e) == 33, "");
#endif
_Static_assert(sizeof(A314) == 6, "");
_Static_assert(_Alignof(A314) == 2, "");
_Static_assert(sizeof(struct A314_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A314_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A314_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A314_extra_packed) == 1, "");
_Static_assert(sizeof(struct A314_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A314_extra_size) == 8, "");
_Static_assert(_Alignof(struct A314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A314,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A314,e) == 33, "");
#endif
_Static_assert(sizeof(A315) == 5, "");
_Static_assert(_Alignof(A315) == 1, "");
_Static_assert(sizeof(struct A315_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A315_extra_packed) == 1, "");
_Static_assert(sizeof(struct A315_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A315_extra_size) == 7, "");
_Static_assert(_Alignof(struct A315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A315,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A315,e) == 33, "");
#endif
_Static_assert(sizeof(A316) == 5, "");
_Static_assert(_Alignof(A316) == 1, "");
_Static_assert(sizeof(struct A316_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A316_extra_packed) == 1, "");
_Static_assert(sizeof(struct A316_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A316_extra_size) == 7, "");
_Static_assert(_Alignof(struct A316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A316,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A316,e) == 33, "");
#endif
_Static_assert(sizeof(A317) == 6, "");
_Static_assert(_Alignof(A317) == 2, "");
_Static_assert(sizeof(struct A317_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A317_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A317_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A317_extra_packed) == 1, "");
_Static_assert(sizeof(struct A317_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A317_extra_size) == 8, "");
_Static_assert(_Alignof(struct A317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A317,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A317,e) == 33, "");
#endif
_Static_assert(sizeof(A318) == 6, "");
_Static_assert(_Alignof(A318) == 2, "");
_Static_assert(sizeof(struct A318_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A318_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A318_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A318_extra_packed) == 1, "");
_Static_assert(sizeof(struct A318_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A318_extra_size) == 8, "");
_Static_assert(_Alignof(struct A318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A318,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A318,e) == 33, "");
#endif
_Static_assert(sizeof(A319) == 6, "");
_Static_assert(_Alignof(A319) == 2, "");
_Static_assert(sizeof(struct A319_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A319_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A319_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A319_extra_packed) == 1, "");
_Static_assert(sizeof(struct A319_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A319_extra_size) == 8, "");
_Static_assert(_Alignof(struct A319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A319,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A319,e) == 33, "");
#endif
_Static_assert(sizeof(A410) == 6, "");
_Static_assert(_Alignof(A410) == 2, "");
_Static_assert(sizeof(struct A410_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A410_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A410_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A410_extra_packed) == 1, "");
_Static_assert(sizeof(struct A410_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A410_extra_size) == 8, "");
_Static_assert(_Alignof(struct A410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A410,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A410,e) == 46, "");
#endif
_Static_assert(sizeof(A411) == 5, "");
_Static_assert(_Alignof(A411) == 1, "");
_Static_assert(sizeof(struct A411_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A411_extra_packed) == 1, "");
_Static_assert(sizeof(struct A411_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A411_extra_size) == 7, "");
_Static_assert(_Alignof(struct A411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A411,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A411,e) == 32, "");
#endif
_Static_assert(sizeof(A412) == 6, "");
_Static_assert(_Alignof(A412) == 2, "");
_Static_assert(sizeof(struct A412_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A412_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A412_extra_packed) == 1, "");
_Static_assert(sizeof(struct A412_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A412_extra_size) == 8, "");
_Static_assert(_Alignof(struct A412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A412,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A412,e) == 32, "");
#endif
_Static_assert(sizeof(A413) == 8, "");
_Static_assert(_Alignof(A413) == 4, "");
_Static_assert(sizeof(struct A413_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A413_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A413_extra_packed) == 1, "");
_Static_assert(sizeof(struct A413_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A413_extra_size) == 10, "");
_Static_assert(_Alignof(struct A413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A413,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A413,e) == 62, "");
#endif
_Static_assert(sizeof(A414) == 8, "");
_Static_assert(_Alignof(A414) == 4, "");
_Static_assert(sizeof(struct A414_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A414_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A414_extra_packed) == 1, "");
_Static_assert(sizeof(struct A414_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A414_extra_size) == 10, "");
_Static_assert(_Alignof(struct A414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A414,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A414,e) == 62, "");
#endif
_Static_assert(sizeof(A415) == 6, "");
_Static_assert(_Alignof(A415) == 2, "");
_Static_assert(sizeof(struct A415_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A415_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A415_extra_packed) == 1, "");
_Static_assert(sizeof(struct A415_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A415_extra_size) == 8, "");
_Static_assert(_Alignof(struct A415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A415,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(A415,e) == 46, "");
#endif
_Static_assert(sizeof(A416) == 5, "");
_Static_assert(_Alignof(A416) == 1, "");
_Static_assert(sizeof(struct A416_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A416_extra_packed) == 1, "");
_Static_assert(sizeof(struct A416_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A416_extra_size) == 7, "");
_Static_assert(_Alignof(struct A416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A416,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A416,e) == 32, "");
#endif
_Static_assert(sizeof(A417) == 6, "");
_Static_assert(_Alignof(A417) == 2, "");
_Static_assert(sizeof(struct A417_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A417_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A417_extra_packed) == 1, "");
_Static_assert(sizeof(struct A417_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A417_extra_size) == 8, "");
_Static_assert(_Alignof(struct A417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A417,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A417,e) == 32, "");
#endif
_Static_assert(sizeof(A418) == 8, "");
_Static_assert(_Alignof(A418) == 4, "");
_Static_assert(sizeof(struct A418_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A418_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A418_extra_packed) == 1, "");
_Static_assert(sizeof(struct A418_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A418_extra_size) == 10, "");
_Static_assert(_Alignof(struct A418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A418,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A418,e) == 62, "");
#endif
_Static_assert(sizeof(A419) == 8, "");
_Static_assert(_Alignof(A419) == 4, "");
_Static_assert(sizeof(struct A419_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A419_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A419_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A419_extra_packed) == 1, "");
_Static_assert(sizeof(struct A419_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A419_extra_size) == 10, "");
_Static_assert(_Alignof(struct A419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A419,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(A419,e) == 62, "");
#endif
_Static_assert(sizeof(A510) == 6, "");
_Static_assert(_Alignof(A510) == 2, "");
_Static_assert(sizeof(struct A510_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A510_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A510_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A510_extra_packed) == 1, "");
_Static_assert(sizeof(struct A510_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A510_extra_size) == 8, "");
_Static_assert(_Alignof(struct A510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A510,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A510,e) == 32, "");
#endif
_Static_assert(sizeof(A511) == 5, "");
_Static_assert(_Alignof(A511) == 1, "");
_Static_assert(sizeof(struct A511_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A511_extra_packed) == 1, "");
_Static_assert(sizeof(struct A511_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A511_extra_size) == 7, "");
_Static_assert(_Alignof(struct A511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A511,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A511,e) == 32, "");
#endif
_Static_assert(sizeof(A512) == 6, "");
_Static_assert(_Alignof(A512) == 2, "");
_Static_assert(sizeof(struct A512_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A512_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A512_extra_packed) == 1, "");
_Static_assert(sizeof(struct A512_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A512_extra_size) == 8, "");
_Static_assert(_Alignof(struct A512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A512,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A512,e) == 32, "");
#endif
_Static_assert(sizeof(A513) == 6, "");
_Static_assert(_Alignof(A513) == 2, "");
_Static_assert(sizeof(struct A513_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A513_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A513_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A513_extra_packed) == 1, "");
_Static_assert(sizeof(struct A513_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A513_extra_size) == 8, "");
_Static_assert(_Alignof(struct A513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A513,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A513,e) == 32, "");
#endif
_Static_assert(sizeof(A514) == 6, "");
_Static_assert(_Alignof(A514) == 2, "");
_Static_assert(sizeof(struct A514_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A514_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A514_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A514_extra_packed) == 1, "");
_Static_assert(sizeof(struct A514_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A514_extra_size) == 8, "");
_Static_assert(_Alignof(struct A514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A514,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A514,e) == 32, "");
#endif
_Static_assert(sizeof(A515) == 5, "");
_Static_assert(_Alignof(A515) == 1, "");
_Static_assert(sizeof(struct A515_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A515_extra_packed) == 1, "");
_Static_assert(sizeof(struct A515_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A515_extra_size) == 7, "");
_Static_assert(_Alignof(struct A515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A515,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A515,e) == 32, "");
#endif
_Static_assert(sizeof(A516) == 5, "");
_Static_assert(_Alignof(A516) == 1, "");
_Static_assert(sizeof(struct A516_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A516_extra_packed) == 1, "");
_Static_assert(sizeof(struct A516_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A516_extra_size) == 7, "");
_Static_assert(_Alignof(struct A516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A516,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A516,e) == 32, "");
#endif
_Static_assert(sizeof(A517) == 6, "");
_Static_assert(_Alignof(A517) == 2, "");
_Static_assert(sizeof(struct A517_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A517_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A517_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A517_extra_packed) == 1, "");
_Static_assert(sizeof(struct A517_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A517_extra_size) == 8, "");
_Static_assert(_Alignof(struct A517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A517,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A517,e) == 32, "");
#endif
_Static_assert(sizeof(A518) == 6, "");
_Static_assert(_Alignof(A518) == 2, "");
_Static_assert(sizeof(struct A518_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A518_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A518_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A518_extra_packed) == 1, "");
_Static_assert(sizeof(struct A518_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A518_extra_size) == 8, "");
_Static_assert(_Alignof(struct A518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A518,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A518,e) == 32, "");
#endif
_Static_assert(sizeof(A519) == 6, "");
_Static_assert(_Alignof(A519) == 2, "");
_Static_assert(sizeof(struct A519_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A519_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A519_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A519_extra_packed) == 1, "");
_Static_assert(sizeof(struct A519_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A519_extra_size) == 8, "");
_Static_assert(_Alignof(struct A519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A519,d) == 2, "");
_Static_assert(__builtin_bitoffsetof(A519,e) == 32, "");
#endif
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 2, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B000,e) == 0, "");
#endif
_Static_assert(sizeof(B001) == 1, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 3, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B001,e) == 0, "");
#endif
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 2, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B002,e) == 0, "");
#endif
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 4, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B003,e) == 0, "");
#endif
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 4, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B004,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B004,e) == 0, "");
#endif
_Static_assert(sizeof(B005) == 2, "");
_Static_assert(_Alignof(B005) == 2, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B005_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 4, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B005,e) == 0, "");
#endif
_Static_assert(sizeof(B006) == 1, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 3, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B006,e) == 0, "");
#endif
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 2, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B007,e) == 0, "");
#endif
_Static_assert(sizeof(B008) == 4, "");
_Static_assert(_Alignof(B008) == 4, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B008_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 6, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B008,e) == 0, "");
#endif
_Static_assert(sizeof(B009) == 4, "");
_Static_assert(_Alignof(B009) == 4, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B009_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 6, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B009,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B009,e) == 0, "");
#endif
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 2, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B010,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B010,e) == 0, "");
#endif
_Static_assert(sizeof(B011) == 1, "");
_Static_assert(_Alignof(B011) == 1, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 3, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B011,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B011,e) == 0, "");
#endif
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 2, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B012,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B012,e) == 0, "");
#endif
_Static_assert(sizeof(B013) == 4, "");
_Static_assert(_Alignof(B013) == 4, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B013_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 6, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B013,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B013,e) == 0, "");
#endif
_Static_assert(sizeof(B014) == 4, "");
_Static_assert(_Alignof(B014) == 4, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B014_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 6, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B014,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B014,e) == 0, "");
#endif
_Static_assert(sizeof(B015) == 2, "");
_Static_assert(_Alignof(B015) == 2, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 4, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B015,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B015,e) == 0, "");
#endif
_Static_assert(sizeof(B016) == 1, "");
_Static_assert(_Alignof(B016) == 1, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 3, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B016,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B016,e) == 0, "");
#endif
_Static_assert(sizeof(B017) == 2, "");
_Static_assert(_Alignof(B017) == 2, "");
_Static_assert(sizeof(struct B017_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B017_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B017_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B017_extra_packed) == 1, "");
_Static_assert(sizeof(struct B017_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B017_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B017_extra_size) == 4, "");
_Static_assert(_Alignof(struct B017_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B017,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B017,e) == 0, "");
#endif
_Static_assert(sizeof(B018) == 4, "");
_Static_assert(_Alignof(B018) == 4, "");
_Static_assert(sizeof(struct B018_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B018_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B018_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B018_extra_packed) == 1, "");
_Static_assert(sizeof(struct B018_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B018_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B018_extra_size) == 6, "");
_Static_assert(_Alignof(struct B018_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B018,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B018,e) == 0, "");
#endif
_Static_assert(sizeof(B019) == 4, "");
_Static_assert(_Alignof(B019) == 4, "");
_Static_assert(sizeof(struct B019_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B019_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B019_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B019_extra_packed) == 1, "");
_Static_assert(sizeof(struct B019_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B019_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B019_extra_size) == 6, "");
_Static_assert(_Alignof(struct B019_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B019,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B019,e) == 0, "");
#endif
_Static_assert(sizeof(B100) == 2, "");
_Static_assert(_Alignof(B100) == 2, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B100_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 4, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B100,e) == 0, "");
#endif
_Static_assert(sizeof(B101) == 1, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 3, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B101,e) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B102,e) == 0, "");
#endif
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B103,e) == 0, "");
#endif
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 4, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B104,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B104,e) == 0, "");
#endif
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B105,e) == 0, "");
#endif
_Static_assert(sizeof(B106) == 1, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 3, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B106,e) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B107,e) == 0, "");
#endif
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 4, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B108,e) == 0, "");
#endif
_Static_assert(sizeof(B109) == 4, "");
_Static_assert(_Alignof(B109) == 4, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 6, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B109,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B109,e) == 0, "");
#endif
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 2, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B110,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B110,e) == 0, "");
#endif
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 1, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B111,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B111,e) == 0, "");
#endif
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 2, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B112,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B112,e) == 0, "");
#endif
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B113,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B113,e) == 0, "");
#endif
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 4, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B114,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B114,e) == 0, "");
#endif
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 2, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B115,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B115,e) == 0, "");
#endif
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 1, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B116,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B116,e) == 0, "");
#endif
_Static_assert(sizeof(B117) == 4, "");
_Static_assert(_Alignof(B117) == 2, "");
_Static_assert(sizeof(struct B117_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B117_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B117_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B117_extra_packed) == 1, "");
_Static_assert(sizeof(struct B117_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B117_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B117_extra_size) == 6, "");
_Static_assert(_Alignof(struct B117_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B117,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B117,e) == 0, "");
#endif
_Static_assert(sizeof(B118) == 4, "");
_Static_assert(_Alignof(B118) == 4, "");
_Static_assert(sizeof(struct B118_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B118_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B118_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B118_extra_packed) == 1, "");
_Static_assert(sizeof(struct B118_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B118_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B118_extra_size) == 6, "");
_Static_assert(_Alignof(struct B118_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B118,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B118,e) == 0, "");
#endif
_Static_assert(sizeof(B119) == 4, "");
_Static_assert(_Alignof(B119) == 4, "");
_Static_assert(sizeof(struct B119_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B119_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B119_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B119_extra_packed) == 1, "");
_Static_assert(sizeof(struct B119_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B119_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B119_extra_size) == 6, "");
_Static_assert(_Alignof(struct B119_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B119,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B119,e) == 0, "");
#endif
_Static_assert(sizeof(B200) == 1, "");
_Static_assert(_Alignof(B200) == 1, "");
_Static_assert(sizeof(struct B200_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B200_extra_packed) == 1, "");
_Static_assert(sizeof(struct B200_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B200_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B200_extra_size) == 3, "");
_Static_assert(_Alignof(struct B200_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B200,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B200,e) == 0, "");
#endif
_Static_assert(sizeof(B201) == 1, "");
_Static_assert(_Alignof(B201) == 1, "");
_Static_assert(sizeof(struct B201_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B201_extra_packed) == 1, "");
_Static_assert(sizeof(struct B201_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B201_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B201_extra_size) == 3, "");
_Static_assert(_Alignof(struct B201_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B201,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B201,e) == 0, "");
#endif
_Static_assert(sizeof(B202) == 1, "");
_Static_assert(_Alignof(B202) == 1, "");
_Static_assert(sizeof(struct B202_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B202_extra_packed) == 1, "");
_Static_assert(sizeof(struct B202_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B202_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B202_extra_size) == 3, "");
_Static_assert(_Alignof(struct B202_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B202,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B202,e) == 0, "");
#endif
_Static_assert(sizeof(B203) == 1, "");
_Static_assert(_Alignof(B203) == 1, "");
_Static_assert(sizeof(struct B203_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B203_extra_packed) == 1, "");
_Static_assert(sizeof(struct B203_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B203_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B203_extra_size) == 3, "");
_Static_assert(_Alignof(struct B203_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B203,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B203,e) == 0, "");
#endif
_Static_assert(sizeof(B204) == 1, "");
_Static_assert(_Alignof(B204) == 1, "");
_Static_assert(sizeof(struct B204_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B204_extra_packed) == 1, "");
_Static_assert(sizeof(struct B204_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B204_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B204_extra_size) == 3, "");
_Static_assert(_Alignof(struct B204_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B204,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B204,e) == 0, "");
#endif
_Static_assert(sizeof(B205) == 1, "");
_Static_assert(_Alignof(B205) == 1, "");
_Static_assert(sizeof(struct B205_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B205_extra_packed) == 1, "");
_Static_assert(sizeof(struct B205_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B205_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B205_extra_size) == 3, "");
_Static_assert(_Alignof(struct B205_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B205,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B205,e) == 0, "");
#endif
_Static_assert(sizeof(B206) == 1, "");
_Static_assert(_Alignof(B206) == 1, "");
_Static_assert(sizeof(struct B206_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B206_extra_packed) == 1, "");
_Static_assert(sizeof(struct B206_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B206_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B206_extra_size) == 3, "");
_Static_assert(_Alignof(struct B206_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B206,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B206,e) == 0, "");
#endif
_Static_assert(sizeof(B207) == 1, "");
_Static_assert(_Alignof(B207) == 1, "");
_Static_assert(sizeof(struct B207_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B207_extra_packed) == 1, "");
_Static_assert(sizeof(struct B207_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B207_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B207_extra_size) == 3, "");
_Static_assert(_Alignof(struct B207_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B207,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B207,e) == 0, "");
#endif
_Static_assert(sizeof(B208) == 1, "");
_Static_assert(_Alignof(B208) == 1, "");
_Static_assert(sizeof(struct B208_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B208_extra_packed) == 1, "");
_Static_assert(sizeof(struct B208_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B208_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B208_extra_size) == 3, "");
_Static_assert(_Alignof(struct B208_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B208,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B208,e) == 0, "");
#endif
_Static_assert(sizeof(B209) == 1, "");
_Static_assert(_Alignof(B209) == 1, "");
_Static_assert(sizeof(struct B209_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B209_extra_packed) == 1, "");
_Static_assert(sizeof(struct B209_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B209_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B209_extra_size) == 3, "");
_Static_assert(_Alignof(struct B209_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B209,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B209,e) == 0, "");
#endif
_Static_assert(sizeof(B210) == 1, "");
_Static_assert(_Alignof(B210) == 1, "");
_Static_assert(sizeof(struct B210_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B210_extra_packed) == 1, "");
_Static_assert(sizeof(struct B210_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B210_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B210_extra_size) == 3, "");
_Static_assert(_Alignof(struct B210_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B210,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B210,e) == 0, "");
#endif
_Static_assert(sizeof(B211) == 1, "");
_Static_assert(_Alignof(B211) == 1, "");
_Static_assert(sizeof(struct B211_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B211_extra_packed) == 1, "");
_Static_assert(sizeof(struct B211_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B211_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B211_extra_size) == 3, "");
_Static_assert(_Alignof(struct B211_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B211,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B211,e) == 0, "");
#endif
_Static_assert(sizeof(B212) == 1, "");
_Static_assert(_Alignof(B212) == 1, "");
_Static_assert(sizeof(struct B212_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B212_extra_packed) == 1, "");
_Static_assert(sizeof(struct B212_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B212_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B212_extra_size) == 3, "");
_Static_assert(_Alignof(struct B212_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B212,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B212,e) == 0, "");
#endif
_Static_assert(sizeof(B213) == 1, "");
_Static_assert(_Alignof(B213) == 1, "");
_Static_assert(sizeof(struct B213_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B213_extra_packed) == 1, "");
_Static_assert(sizeof(struct B213_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B213_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B213_extra_size) == 3, "");
_Static_assert(_Alignof(struct B213_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B213,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B213,e) == 0, "");
#endif
_Static_assert(sizeof(B214) == 1, "");
_Static_assert(_Alignof(B214) == 1, "");
_Static_assert(sizeof(struct B214_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B214_extra_packed) == 1, "");
_Static_assert(sizeof(struct B214_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B214_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B214_extra_size) == 3, "");
_Static_assert(_Alignof(struct B214_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B214,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B214,e) == 0, "");
#endif
_Static_assert(sizeof(B215) == 1, "");
_Static_assert(_Alignof(B215) == 1, "");
_Static_assert(sizeof(struct B215_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B215_extra_packed) == 1, "");
_Static_assert(sizeof(struct B215_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B215_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B215_extra_size) == 3, "");
_Static_assert(_Alignof(struct B215_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B215,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B215,e) == 0, "");
#endif
_Static_assert(sizeof(B216) == 1, "");
_Static_assert(_Alignof(B216) == 1, "");
_Static_assert(sizeof(struct B216_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B216_extra_packed) == 1, "");
_Static_assert(sizeof(struct B216_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B216_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B216_extra_size) == 3, "");
_Static_assert(_Alignof(struct B216_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B216,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B216,e) == 0, "");
#endif
_Static_assert(sizeof(B217) == 1, "");
_Static_assert(_Alignof(B217) == 1, "");
_Static_assert(sizeof(struct B217_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B217_extra_packed) == 1, "");
_Static_assert(sizeof(struct B217_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B217_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B217_extra_size) == 3, "");
_Static_assert(_Alignof(struct B217_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B217,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B217,e) == 0, "");
#endif
_Static_assert(sizeof(B218) == 1, "");
_Static_assert(_Alignof(B218) == 1, "");
_Static_assert(sizeof(struct B218_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B218_extra_packed) == 1, "");
_Static_assert(sizeof(struct B218_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B218_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B218_extra_size) == 3, "");
_Static_assert(_Alignof(struct B218_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B218,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B218,e) == 0, "");
#endif
_Static_assert(sizeof(B219) == 1, "");
_Static_assert(_Alignof(B219) == 1, "");
_Static_assert(sizeof(struct B219_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B219_extra_packed) == 1, "");
_Static_assert(sizeof(struct B219_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B219_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B219_extra_size) == 3, "");
_Static_assert(_Alignof(struct B219_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B219,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B219,e) == 0, "");
#endif
_Static_assert(sizeof(B300) == 2, "");
_Static_assert(_Alignof(B300) == 2, "");
_Static_assert(sizeof(struct B300_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B300_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B300_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B300_extra_packed) == 1, "");
_Static_assert(sizeof(struct B300_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B300_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B300_extra_size) == 4, "");
_Static_assert(_Alignof(struct B300_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B300,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B300,e) == 0, "");
#endif
_Static_assert(sizeof(B301) == 1, "");
_Static_assert(_Alignof(B301) == 1, "");
_Static_assert(sizeof(struct B301_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B301_extra_packed) == 1, "");
_Static_assert(sizeof(struct B301_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B301_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B301_extra_size) == 3, "");
_Static_assert(_Alignof(struct B301_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B301,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B301,e) == 0, "");
#endif
_Static_assert(sizeof(B302) == 2, "");
_Static_assert(_Alignof(B302) == 2, "");
_Static_assert(sizeof(struct B302_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B302_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B302_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B302_extra_packed) == 1, "");
_Static_assert(sizeof(struct B302_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B302_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B302_extra_size) == 4, "");
_Static_assert(_Alignof(struct B302_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B302,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B302,e) == 0, "");
#endif
_Static_assert(sizeof(B303) == 2, "");
_Static_assert(_Alignof(B303) == 2, "");
_Static_assert(sizeof(struct B303_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B303_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B303_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B303_extra_packed) == 1, "");
_Static_assert(sizeof(struct B303_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B303_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B303_extra_size) == 4, "");
_Static_assert(_Alignof(struct B303_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B303,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B303,e) == 0, "");
#endif
_Static_assert(sizeof(B304) == 2, "");
_Static_assert(_Alignof(B304) == 2, "");
_Static_assert(sizeof(struct B304_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B304_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B304_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B304_extra_packed) == 1, "");
_Static_assert(sizeof(struct B304_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B304_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B304_extra_size) == 4, "");
_Static_assert(_Alignof(struct B304_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B304,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B304,e) == 0, "");
#endif
_Static_assert(sizeof(B305) == 1, "");
_Static_assert(_Alignof(B305) == 1, "");
_Static_assert(sizeof(struct B305_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B305_extra_packed) == 1, "");
_Static_assert(sizeof(struct B305_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B305_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B305_extra_size) == 3, "");
_Static_assert(_Alignof(struct B305_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B305,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B305,e) == 0, "");
#endif
_Static_assert(sizeof(B306) == 1, "");
_Static_assert(_Alignof(B306) == 1, "");
_Static_assert(sizeof(struct B306_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B306_extra_packed) == 1, "");
_Static_assert(sizeof(struct B306_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B306_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B306_extra_size) == 3, "");
_Static_assert(_Alignof(struct B306_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B306,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B306,e) == 0, "");
#endif
_Static_assert(sizeof(B307) == 2, "");
_Static_assert(_Alignof(B307) == 2, "");
_Static_assert(sizeof(struct B307_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B307_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B307_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B307_extra_packed) == 1, "");
_Static_assert(sizeof(struct B307_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B307_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B307_extra_size) == 4, "");
_Static_assert(_Alignof(struct B307_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B307,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B307,e) == 0, "");
#endif
_Static_assert(sizeof(B308) == 2, "");
_Static_assert(_Alignof(B308) == 2, "");
_Static_assert(sizeof(struct B308_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B308_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B308_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B308_extra_packed) == 1, "");
_Static_assert(sizeof(struct B308_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B308_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B308_extra_size) == 4, "");
_Static_assert(_Alignof(struct B308_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B308,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B308,e) == 0, "");
#endif
_Static_assert(sizeof(B309) == 2, "");
_Static_assert(_Alignof(B309) == 2, "");
_Static_assert(sizeof(struct B309_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B309_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B309_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B309_extra_packed) == 1, "");
_Static_assert(sizeof(struct B309_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B309_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B309_extra_size) == 4, "");
_Static_assert(_Alignof(struct B309_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B309,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B309,e) == 0, "");
#endif
_Static_assert(sizeof(B310) == 4, "");
_Static_assert(_Alignof(B310) == 2, "");
_Static_assert(sizeof(struct B310_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B310_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B310_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B310_extra_packed) == 1, "");
_Static_assert(sizeof(struct B310_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B310_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B310_extra_size) == 6, "");
_Static_assert(_Alignof(struct B310_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B310,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B310,e) == 0, "");
#endif
_Static_assert(sizeof(B311) == 4, "");
_Static_assert(_Alignof(B311) == 1, "");
_Static_assert(sizeof(struct B311_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B311_extra_packed) == 1, "");
_Static_assert(sizeof(struct B311_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B311_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B311_extra_size) == 6, "");
_Static_assert(_Alignof(struct B311_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B311,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B311,e) == 0, "");
#endif
_Static_assert(sizeof(B312) == 4, "");
_Static_assert(_Alignof(B312) == 2, "");
_Static_assert(sizeof(struct B312_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B312_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B312_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B312_extra_packed) == 1, "");
_Static_assert(sizeof(struct B312_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B312_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B312_extra_size) == 6, "");
_Static_assert(_Alignof(struct B312_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B312,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B312,e) == 0, "");
#endif
_Static_assert(sizeof(B313) == 4, "");
_Static_assert(_Alignof(B313) == 2, "");
_Static_assert(sizeof(struct B313_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B313_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B313_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B313_extra_packed) == 1, "");
_Static_assert(sizeof(struct B313_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B313_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B313_extra_size) == 6, "");
_Static_assert(_Alignof(struct B313_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B313,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B313,e) == 0, "");
#endif
_Static_assert(sizeof(B314) == 4, "");
_Static_assert(_Alignof(B314) == 2, "");
_Static_assert(sizeof(struct B314_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B314_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B314_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B314_extra_packed) == 1, "");
_Static_assert(sizeof(struct B314_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B314_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B314_extra_size) == 6, "");
_Static_assert(_Alignof(struct B314_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B314,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B314,e) == 0, "");
#endif
_Static_assert(sizeof(B315) == 4, "");
_Static_assert(_Alignof(B315) == 1, "");
_Static_assert(sizeof(struct B315_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B315_extra_packed) == 1, "");
_Static_assert(sizeof(struct B315_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B315_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B315_extra_size) == 6, "");
_Static_assert(_Alignof(struct B315_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B315,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B315,e) == 0, "");
#endif
_Static_assert(sizeof(B316) == 4, "");
_Static_assert(_Alignof(B316) == 1, "");
_Static_assert(sizeof(struct B316_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B316_extra_packed) == 1, "");
_Static_assert(sizeof(struct B316_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B316_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B316_extra_size) == 6, "");
_Static_assert(_Alignof(struct B316_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B316,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B316,e) == 0, "");
#endif
_Static_assert(sizeof(B317) == 4, "");
_Static_assert(_Alignof(B317) == 2, "");
_Static_assert(sizeof(struct B317_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B317_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B317_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B317_extra_packed) == 1, "");
_Static_assert(sizeof(struct B317_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B317_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B317_extra_size) == 6, "");
_Static_assert(_Alignof(struct B317_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B317,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B317,e) == 0, "");
#endif
_Static_assert(sizeof(B318) == 4, "");
_Static_assert(_Alignof(B318) == 2, "");
_Static_assert(sizeof(struct B318_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B318_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B318_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B318_extra_packed) == 1, "");
_Static_assert(sizeof(struct B318_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B318_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B318_extra_size) == 6, "");
_Static_assert(_Alignof(struct B318_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B318,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B318,e) == 0, "");
#endif
_Static_assert(sizeof(B319) == 4, "");
_Static_assert(_Alignof(B319) == 2, "");
_Static_assert(sizeof(struct B319_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B319_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B319_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B319_extra_packed) == 1, "");
_Static_assert(sizeof(struct B319_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B319_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B319_extra_size) == 6, "");
_Static_assert(_Alignof(struct B319_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B319,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B319,e) == 0, "");
#endif
_Static_assert(sizeof(B410) == 4, "");
_Static_assert(_Alignof(B410) == 2, "");
_Static_assert(sizeof(struct B410_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B410_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B410_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B410_extra_packed) == 1, "");
_Static_assert(sizeof(struct B410_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B410_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B410_extra_size) == 6, "");
_Static_assert(_Alignof(struct B410_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B410,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B410,e) == 0, "");
#endif
_Static_assert(sizeof(B411) == 4, "");
_Static_assert(_Alignof(B411) == 1, "");
_Static_assert(sizeof(struct B411_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B411_extra_packed) == 1, "");
_Static_assert(sizeof(struct B411_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B411_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B411_extra_size) == 6, "");
_Static_assert(_Alignof(struct B411_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B411,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B411,e) == 0, "");
#endif
_Static_assert(sizeof(B412) == 4, "");
_Static_assert(_Alignof(B412) == 2, "");
_Static_assert(sizeof(struct B412_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B412_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B412_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B412_extra_packed) == 1, "");
_Static_assert(sizeof(struct B412_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B412_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B412_extra_size) == 6, "");
_Static_assert(_Alignof(struct B412_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B412,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B412,e) == 0, "");
#endif
_Static_assert(sizeof(B413) == 4, "");
_Static_assert(_Alignof(B413) == 4, "");
_Static_assert(sizeof(struct B413_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B413_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B413_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B413_extra_packed) == 1, "");
_Static_assert(sizeof(struct B413_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B413_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B413_extra_size) == 6, "");
_Static_assert(_Alignof(struct B413_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B413,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B413,e) == 0, "");
#endif
_Static_assert(sizeof(B414) == 4, "");
_Static_assert(_Alignof(B414) == 4, "");
_Static_assert(sizeof(struct B414_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B414_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B414_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B414_extra_packed) == 1, "");
_Static_assert(sizeof(struct B414_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B414_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B414_extra_size) == 6, "");
_Static_assert(_Alignof(struct B414_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B414,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B414,e) == 0, "");
#endif
_Static_assert(sizeof(B415) == 4, "");
_Static_assert(_Alignof(B415) == 2, "");
_Static_assert(sizeof(struct B415_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B415_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B415_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B415_extra_packed) == 1, "");
_Static_assert(sizeof(struct B415_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B415_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B415_extra_size) == 6, "");
_Static_assert(_Alignof(struct B415_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B415,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B415,e) == 0, "");
#endif
_Static_assert(sizeof(B416) == 4, "");
_Static_assert(_Alignof(B416) == 1, "");
_Static_assert(sizeof(struct B416_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B416_extra_packed) == 1, "");
_Static_assert(sizeof(struct B416_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B416_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B416_extra_size) == 6, "");
_Static_assert(_Alignof(struct B416_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B416,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B416,e) == 0, "");
#endif
_Static_assert(sizeof(B417) == 4, "");
_Static_assert(_Alignof(B417) == 2, "");
_Static_assert(sizeof(struct B417_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B417_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B417_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B417_extra_packed) == 1, "");
_Static_assert(sizeof(struct B417_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B417_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B417_extra_size) == 6, "");
_Static_assert(_Alignof(struct B417_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B417,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B417,e) == 0, "");
#endif
_Static_assert(sizeof(B418) == 4, "");
_Static_assert(_Alignof(B418) == 4, "");
_Static_assert(sizeof(struct B418_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B418_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B418_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B418_extra_packed) == 1, "");
_Static_assert(sizeof(struct B418_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B418_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B418_extra_size) == 6, "");
_Static_assert(_Alignof(struct B418_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B418,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B418,e) == 0, "");
#endif
_Static_assert(sizeof(B419) == 4, "");
_Static_assert(_Alignof(B419) == 4, "");
_Static_assert(sizeof(struct B419_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B419_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B419_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B419_extra_packed) == 1, "");
_Static_assert(sizeof(struct B419_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B419_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B419_extra_size) == 6, "");
_Static_assert(_Alignof(struct B419_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B419,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B419,e) == 0, "");
#endif
_Static_assert(sizeof(B510) == 4, "");
_Static_assert(_Alignof(B510) == 2, "");
_Static_assert(sizeof(struct B510_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B510_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B510_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B510_extra_packed) == 1, "");
_Static_assert(sizeof(struct B510_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B510_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B510_extra_size) == 6, "");
_Static_assert(_Alignof(struct B510_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B510,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B510,e) == 0, "");
#endif
_Static_assert(sizeof(B511) == 4, "");
_Static_assert(_Alignof(B511) == 1, "");
_Static_assert(sizeof(struct B511_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B511_extra_packed) == 1, "");
_Static_assert(sizeof(struct B511_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B511_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B511_extra_size) == 6, "");
_Static_assert(_Alignof(struct B511_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B511,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B511,e) == 0, "");
#endif
_Static_assert(sizeof(B512) == 4, "");
_Static_assert(_Alignof(B512) == 2, "");
_Static_assert(sizeof(struct B512_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B512_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B512_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B512_extra_packed) == 1, "");
_Static_assert(sizeof(struct B512_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B512_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B512_extra_size) == 6, "");
_Static_assert(_Alignof(struct B512_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B512,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B512,e) == 0, "");
#endif
_Static_assert(sizeof(B513) == 4, "");
_Static_assert(_Alignof(B513) == 2, "");
_Static_assert(sizeof(struct B513_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B513_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B513_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B513_extra_packed) == 1, "");
_Static_assert(sizeof(struct B513_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B513_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B513_extra_size) == 6, "");
_Static_assert(_Alignof(struct B513_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B513,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B513,e) == 0, "");
#endif
_Static_assert(sizeof(B514) == 4, "");
_Static_assert(_Alignof(B514) == 2, "");
_Static_assert(sizeof(struct B514_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B514_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B514_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B514_extra_packed) == 1, "");
_Static_assert(sizeof(struct B514_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B514_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B514_extra_size) == 6, "");
_Static_assert(_Alignof(struct B514_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B514,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B514,e) == 0, "");
#endif
_Static_assert(sizeof(B515) == 4, "");
_Static_assert(_Alignof(B515) == 1, "");
_Static_assert(sizeof(struct B515_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B515_extra_packed) == 1, "");
_Static_assert(sizeof(struct B515_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B515_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B515_extra_size) == 6, "");
_Static_assert(_Alignof(struct B515_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B515,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B515,e) == 0, "");
#endif
_Static_assert(sizeof(B516) == 4, "");
_Static_assert(_Alignof(B516) == 1, "");
_Static_assert(sizeof(struct B516_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B516_extra_packed) == 1, "");
_Static_assert(sizeof(struct B516_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B516_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B516_extra_size) == 6, "");
_Static_assert(_Alignof(struct B516_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B516,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B516,e) == 0, "");
#endif
_Static_assert(sizeof(B517) == 4, "");
_Static_assert(_Alignof(B517) == 2, "");
_Static_assert(sizeof(struct B517_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B517_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B517_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B517_extra_packed) == 1, "");
_Static_assert(sizeof(struct B517_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B517_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B517_extra_size) == 6, "");
_Static_assert(_Alignof(struct B517_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B517,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B517,e) == 0, "");
#endif
_Static_assert(sizeof(B518) == 4, "");
_Static_assert(_Alignof(B518) == 2, "");
_Static_assert(sizeof(struct B518_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B518_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B518_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B518_extra_packed) == 1, "");
_Static_assert(sizeof(struct B518_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B518_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B518_extra_size) == 6, "");
_Static_assert(_Alignof(struct B518_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B518,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B518,e) == 0, "");
#endif
_Static_assert(sizeof(B519) == 4, "");
_Static_assert(_Alignof(B519) == 2, "");
_Static_assert(sizeof(struct B519_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B519_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B519_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B519_extra_packed) == 1, "");
_Static_assert(sizeof(struct B519_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B519_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B519_extra_size) == 6, "");
_Static_assert(_Alignof(struct B519_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B519,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(B519,e) == 0, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0084_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c;
int i;
} A000;
A000 var1;
struct A000_extra_alignment {
char a;
A000 b;
};
struct A000_extra_alignment var2;
#pragma pack(1)
struct A000_extra_packed {
A000 a;
};
#pragma pack()
struct A000_extra_required_alignment {
char a;
struct A000_extra_packed b;
};
struct A000_extra_required_alignment var3;
struct A000_extra_size {
char a[sizeof(A000)+1];
char b;
};
struct A000_extra_size var4;
typedef struct {
char c;
int i;
} __attribute__((packed)) A001;
A001 var5;
struct A001_extra_alignment {
char a;
A001 b;
};
struct A001_extra_alignment var6;
#pragma pack(1)
struct A001_extra_packed {
A001 a;
};
#pragma pack()
struct A001_extra_required_alignment {
char a;
struct A001_extra_packed b;
};
struct A001_extra_required_alignment var7;
struct A001_extra_size {
char a[sizeof(A001)+1];
char b;
};
struct A001_extra_size var8;
typedef struct {
char c;
int i __attribute__((packed));
} A002;
A002 var9;
struct A002_extra_alignment {
char a;
A002 b;
};
struct A002_extra_alignment var10;
#pragma pack(1)
struct A002_extra_packed {
A002 a;
};
#pragma pack()
struct A002_extra_required_alignment {
char a;
struct A002_extra_packed b;
};
struct A002_extra_required_alignment var11;
struct A002_extra_size {
char a[sizeof(A002)+1];
char b;
};
struct A002_extra_size var12;
typedef struct {
char c;
int i __attribute__((packed));
} __attribute__((packed)) A003;
A003 var13;
struct A003_extra_alignment {
char a;
A003 b;
};
struct A003_extra_alignment var14;
#pragma pack(1)
struct A003_extra_packed {
A003 a;
};
#pragma pack()
struct A003_extra_required_alignment {
char a;
struct A003_extra_packed b;
};
struct A003_extra_required_alignment var15;
struct A003_extra_size {
char a[sizeof(A003)+1];
char b;
};
struct A003_extra_size var16;
typedef int A004 __attribute__((aligned(16)));
A004 var17;
struct A004_extra_alignment {
char a;
A004 b;
};
struct A004_extra_alignment var18;
#pragma pack(1)
struct A004_extra_packed {
A004 a;
};
#pragma pack()
struct A004_extra_required_alignment {
char a;
struct A004_extra_packed b;
};
struct A004_extra_required_alignment var19;
struct A004_extra_size {
char a[sizeof(A004)+1];
char b;
};
struct A004_extra_size var20;
typedef struct {
char c;
A004 i;
} A005;
A005 var21;
struct A005_extra_alignment {
char a;
A005 b;
};
struct A005_extra_alignment var22;
#pragma pack(1)
struct A005_extra_packed {
A005 a;
};
#pragma pack()
struct A005_extra_required_alignment {
char a;
struct A005_extra_packed b;
};
struct A005_extra_required_alignment var23;
struct A005_extra_size {
char a[sizeof(A005)+1];
char b;
};
struct A005_extra_size var24;
typedef struct {
char c;
A004 i;
} __attribute__((packed)) A006;
A006 var25;
struct A006_extra_alignment {
char a;
A006 b;
};
struct A006_extra_alignment var26;
#pragma pack(1)
struct A006_extra_packed {
A006 a;
};
#pragma pack()
struct A006_extra_required_alignment {
char a;
struct A006_extra_packed b;
};
struct A006_extra_required_alignment var27;
struct A006_extra_size {
char a[sizeof(A006)+1];
char b;
};
struct A006_extra_size var28;
typedef struct {
char c;
A004 i __attribute__((packed));
} A007;
A007 var29;
struct A007_extra_alignment {
char a;
A007 b;
};
struct A007_extra_alignment var30;
#pragma pack(1)
struct A007_extra_packed {
A007 a;
};
#pragma pack()
struct A007_extra_required_alignment {
char a;
struct A007_extra_packed b;
};
struct A007_extra_required_alignment var31;
struct A007_extra_size {
char a[sizeof(A007)+1];
char b;
};
struct A007_extra_size var32;
typedef struct {
char c;
A004 i __attribute__((packed));
} __attribute__((packed)) A008;
A008 var33;
struct A008_extra_alignment {
char a;
A008 b;
};
struct A008_extra_alignment var34;
#pragma pack(1)
struct A008_extra_packed {
A008 a;
};
#pragma pack()
struct A008_extra_required_alignment {
char a;
struct A008_extra_packed b;
};
struct A008_extra_required_alignment var35;
struct A008_extra_size {
char a[sizeof(A008)+1];
char b;
};
struct A008_extra_size var36;
#pragma pack(2)
typedef struct {
char c;
int i;
} A100;
A100 var37;
#pragma pack()
struct A100_extra_alignment {
char a;
A100 b;
};
struct A100_extra_alignment var38;
#pragma pack(1)
struct A100_extra_packed {
A100 a;
};
#pragma pack()
struct A100_extra_required_alignment {
char a;
struct A100_extra_packed b;
};
struct A100_extra_required_alignment var39;
struct A100_extra_size {
char a[sizeof(A100)+1];
char b;
};
struct A100_extra_size var40;
#pragma pack(2)
typedef struct {
char c;
int i;
} __attribute__((packed)) A101;
A101 var41;
#pragma pack()
struct A101_extra_alignment {
char a;
A101 b;
};
struct A101_extra_alignment var42;
#pragma pack(1)
struct A101_extra_packed {
A101 a;
};
#pragma pack()
struct A101_extra_required_alignment {
char a;
struct A101_extra_packed b;
};
struct A101_extra_required_alignment var43;
struct A101_extra_size {
char a[sizeof(A101)+1];
char b;
};
struct A101_extra_size var44;
#pragma pack(2)
typedef struct {
char c;
int i __attribute__((packed));
} A102;
A102 var45;
#pragma pack()
struct A102_extra_alignment {
char a;
A102 b;
};
struct A102_extra_alignment var46;
#pragma pack(1)
struct A102_extra_packed {
A102 a;
};
#pragma pack()
struct A102_extra_required_alignment {
char a;
struct A102_extra_packed b;
};
struct A102_extra_required_alignment var47;
struct A102_extra_size {
char a[sizeof(A102)+1];
char b;
};
struct A102_extra_size var48;
#pragma pack(2)
typedef struct {
char c;
int i __attribute__((packed));
} __attribute__((packed)) A103;
A103 var49;
#pragma pack()
struct A103_extra_alignment {
char a;
A103 b;
};
struct A103_extra_alignment var50;
#pragma pack(1)
struct A103_extra_packed {
A103 a;
};
#pragma pack()
struct A103_extra_required_alignment {
char a;
struct A103_extra_packed b;
};
struct A103_extra_required_alignment var51;
struct A103_extra_size {
char a[sizeof(A103)+1];
char b;
};
struct A103_extra_size var52;
typedef int A104 __attribute__((aligned(16)));
A104 var53;
struct A104_extra_alignment {
char a;
A104 b;
};
struct A104_extra_alignment var54;
#pragma pack(1)
struct A104_extra_packed {
A104 a;
};
#pragma pack()
struct A104_extra_required_alignment {
char a;
struct A104_extra_packed b;
};
struct A104_extra_required_alignment var55;
struct A104_extra_size {
char a[sizeof(A104)+1];
char b;
};
struct A104_extra_size var56;
#pragma pack(2)
typedef struct {
char c;
A104 i;
} A105;
A105 var57;
#pragma pack()
struct A105_extra_alignment {
char a;
A105 b;
};
struct A105_extra_alignment var58;
#pragma pack(1)
struct A105_extra_packed {
A105 a;
};
#pragma pack()
struct A105_extra_required_alignment {
char a;
struct A105_extra_packed b;
};
struct A105_extra_required_alignment var59;
struct A105_extra_size {
char a[sizeof(A105)+1];
char b;
};
struct A105_extra_size var60;
#pragma pack(2)
typedef struct {
char c;
A104 i;
} __attribute__((packed)) A106;
A106 var61;
#pragma pack()
struct A106_extra_alignment {
char a;
A106 b;
};
struct A106_extra_alignment var62;
#pragma pack(1)
struct A106_extra_packed {
A106 a;
};
#pragma pack()
struct A106_extra_required_alignment {
char a;
struct A106_extra_packed b;
};
struct A106_extra_required_alignment var63;
struct A106_extra_size {
char a[sizeof(A106)+1];
char b;
};
struct A106_extra_size var64;
#pragma pack(2)
typedef struct {
char c;
A104 i __attribute__((packed));
} A107;
A107 var65;
#pragma pack()
struct A107_extra_alignment {
char a;
A107 b;
};
struct A107_extra_alignment var66;
#pragma pack(1)
struct A107_extra_packed {
A107 a;
};
#pragma pack()
struct A107_extra_required_alignment {
char a;
struct A107_extra_packed b;
};
struct A107_extra_required_alignment var67;
struct A107_extra_size {
char a[sizeof(A107)+1];
char b;
};
struct A107_extra_size var68;
#pragma pack(2)
typedef struct {
char c;
A104 i __attribute__((packed));
} __attribute__((packed)) A108;
A108 var69;
#pragma pack()
struct A108_extra_alignment {
char a;
A108 b;
};
struct A108_extra_alignment var70;
#pragma pack(1)
struct A108_extra_packed {
A108 a;
};
#pragma pack()
struct A108_extra_required_alignment {
char a;
struct A108_extra_packed b;
};
struct A108_extra_required_alignment var71;
struct A108_extra_size {
char a[sizeof(A108)+1];
char b;
};
struct A108_extra_size var72;
typedef union {
char c;
int i;
} B000;
B000 var73;
struct B000_extra_alignment {
char a;
B000 b;
};
struct B000_extra_alignment var74;
#pragma pack(1)
struct B000_extra_packed {
B000 a;
};
#pragma pack()
struct B000_extra_required_alignment {
char a;
struct B000_extra_packed b;
};
struct B000_extra_required_alignment var75;
struct B000_extra_size {
char a[sizeof(B000)+1];
char b;
};
struct B000_extra_size var76;
typedef union {
char c;
int i;
} __attribute__((packed)) B001;
B001 var77;
struct B001_extra_alignment {
char a;
B001 b;
};
struct B001_extra_alignment var78;
#pragma pack(1)
struct B001_extra_packed {
B001 a;
};
#pragma pack()
struct B001_extra_required_alignment {
char a;
struct B001_extra_packed b;
};
struct B001_extra_required_alignment var79;
struct B001_extra_size {
char a[sizeof(B001)+1];
char b;
};
struct B001_extra_size var80;
typedef union {
char c;
int i __attribute__((packed));
} B002;
B002 var81;
struct B002_extra_alignment {
char a;
B002 b;
};
struct B002_extra_alignment var82;
#pragma pack(1)
struct B002_extra_packed {
B002 a;
};
#pragma pack()
struct B002_extra_required_alignment {
char a;
struct B002_extra_packed b;
};
struct B002_extra_required_alignment var83;
struct B002_extra_size {
char a[sizeof(B002)+1];
char b;
};
struct B002_extra_size var84;
typedef union {
char c;
int i __attribute__((packed));
} __attribute__((packed)) B003;
B003 var85;
struct B003_extra_alignment {
char a;
B003 b;
};
struct B003_extra_alignment var86;
#pragma pack(1)
struct B003_extra_packed {
B003 a;
};
#pragma pack()
struct B003_extra_required_alignment {
char a;
struct B003_extra_packed b;
};
struct B003_extra_required_alignment var87;
struct B003_extra_size {
char a[sizeof(B003)+1];
char b;
};
struct B003_extra_size var88;
typedef int B004 __attribute__((aligned(16)));
B004 var89;
struct B004_extra_alignment {
char a;
B004 b;
};
struct B004_extra_alignment var90;
#pragma pack(1)
struct B004_extra_packed {
B004 a;
};
#pragma pack()
struct B004_extra_required_alignment {
char a;
struct B004_extra_packed b;
};
struct B004_extra_required_alignment var91;
struct B004_extra_size {
char a[sizeof(B004)+1];
char b;
};
struct B004_extra_size var92;
typedef union {
char c;
A004 i;
} B005;
B005 var93;
struct B005_extra_alignment {
char a;
B005 b;
};
struct B005_extra_alignment var94;
#pragma pack(1)
struct B005_extra_packed {
B005 a;
};
#pragma pack()
struct B005_extra_required_alignment {
char a;
struct B005_extra_packed b;
};
struct B005_extra_required_alignment var95;
struct B005_extra_size {
char a[sizeof(B005)+1];
char b;
};
struct B005_extra_size var96;
typedef union {
char c;
A004 i;
} __attribute__((packed)) B006;
B006 var97;
struct B006_extra_alignment {
char a;
B006 b;
};
struct B006_extra_alignment var98;
#pragma pack(1)
struct B006_extra_packed {
B006 a;
};
#pragma pack()
struct B006_extra_required_alignment {
char a;
struct B006_extra_packed b;
};
struct B006_extra_required_alignment var99;
struct B006_extra_size {
char a[sizeof(B006)+1];
char b;
};
struct B006_extra_size var100;
typedef union {
char c;
A004 i __attribute__((packed));
} B007;
B007 var101;
struct B007_extra_alignment {
char a;
B007 b;
};
struct B007_extra_alignment var102;
#pragma pack(1)
struct B007_extra_packed {
B007 a;
};
#pragma pack()
struct B007_extra_required_alignment {
char a;
struct B007_extra_packed b;
};
struct B007_extra_required_alignment var103;
struct B007_extra_size {
char a[sizeof(B007)+1];
char b;
};
struct B007_extra_size var104;
typedef union {
char c;
A004 i __attribute__((packed));
} __attribute__((packed)) B008;
B008 var105;
struct B008_extra_alignment {
char a;
B008 b;
};
struct B008_extra_alignment var106;
#pragma pack(1)
struct B008_extra_packed {
B008 a;
};
#pragma pack()
struct B008_extra_required_alignment {
char a;
struct B008_extra_packed b;
};
struct B008_extra_required_alignment var107;
struct B008_extra_size {
char a[sizeof(B008)+1];
char b;
};
struct B008_extra_size var108;
#pragma pack(2)
typedef union {
char c;
int i;
} B100;
B100 var109;
#pragma pack()
struct B100_extra_alignment {
char a;
B100 b;
};
struct B100_extra_alignment var110;
#pragma pack(1)
struct B100_extra_packed {
B100 a;
};
#pragma pack()
struct B100_extra_required_alignment {
char a;
struct B100_extra_packed b;
};
struct B100_extra_required_alignment var111;
struct B100_extra_size {
char a[sizeof(B100)+1];
char b;
};
struct B100_extra_size var112;
#pragma pack(2)
typedef union {
char c;
int i;
} __attribute__((packed)) B101;
B101 var113;
#pragma pack()
struct B101_extra_alignment {
char a;
B101 b;
};
struct B101_extra_alignment var114;
#pragma pack(1)
struct B101_extra_packed {
B101 a;
};
#pragma pack()
struct B101_extra_required_alignment {
char a;
struct B101_extra_packed b;
};
struct B101_extra_required_alignment var115;
struct B101_extra_size {
char a[sizeof(B101)+1];
char b;
};
struct B101_extra_size var116;
#pragma pack(2)
typedef union {
char c;
int i __attribute__((packed));
} B102;
B102 var117;
#pragma pack()
struct B102_extra_alignment {
char a;
B102 b;
};
struct B102_extra_alignment var118;
#pragma pack(1)
struct B102_extra_packed {
B102 a;
};
#pragma pack()
struct B102_extra_required_alignment {
char a;
struct B102_extra_packed b;
};
struct B102_extra_required_alignment var119;
struct B102_extra_size {
char a[sizeof(B102)+1];
char b;
};
struct B102_extra_size var120;
#pragma pack(2)
typedef union {
char c;
int i __attribute__((packed));
} __attribute__((packed)) B103;
B103 var121;
#pragma pack()
struct B103_extra_alignment {
char a;
B103 b;
};
struct B103_extra_alignment var122;
#pragma pack(1)
struct B103_extra_packed {
B103 a;
};
#pragma pack()
struct B103_extra_required_alignment {
char a;
struct B103_extra_packed b;
};
struct B103_extra_required_alignment var123;
struct B103_extra_size {
char a[sizeof(B103)+1];
char b;
};
struct B103_extra_size var124;
typedef int B104 __attribute__((aligned(16)));
B104 var125;
struct B104_extra_alignment {
char a;
B104 b;
};
struct B104_extra_alignment var126;
#pragma pack(1)
struct B104_extra_packed {
B104 a;
};
#pragma pack()
struct B104_extra_required_alignment {
char a;
struct B104_extra_packed b;
};
struct B104_extra_required_alignment var127;
struct B104_extra_size {
char a[sizeof(B104)+1];
char b;
};
struct B104_extra_size var128;
#pragma pack(2)
typedef union {
char c;
A104 i;
} B105;
B105 var129;
#pragma pack()
struct B105_extra_alignment {
char a;
B105 b;
};
struct B105_extra_alignment var130;
#pragma pack(1)
struct B105_extra_packed {
B105 a;
};
#pragma pack()
struct B105_extra_required_alignment {
char a;
struct B105_extra_packed b;
};
struct B105_extra_required_alignment var131;
struct B105_extra_size {
char a[sizeof(B105)+1];
char b;
};
struct B105_extra_size var132;
#pragma pack(2)
typedef union {
char c;
A104 i;
} __attribute__((packed)) B106;
B106 var133;
#pragma pack()
struct B106_extra_alignment {
char a;
B106 b;
};
struct B106_extra_alignment var134;
#pragma pack(1)
struct B106_extra_packed {
B106 a;
};
#pragma pack()
struct B106_extra_required_alignment {
char a;
struct B106_extra_packed b;
};
struct B106_extra_required_alignment var135;
struct B106_extra_size {
char a[sizeof(B106)+1];
char b;
};
struct B106_extra_size var136;
#pragma pack(2)
typedef union {
char c;
A104 i __attribute__((packed));
} B107;
B107 var137;
#pragma pack()
struct B107_extra_alignment {
char a;
B107 b;
};
struct B107_extra_alignment var138;
#pragma pack(1)
struct B107_extra_packed {
B107 a;
};
#pragma pack()
struct B107_extra_required_alignment {
char a;
struct B107_extra_packed b;
};
struct B107_extra_required_alignment var139;
struct B107_extra_size {
char a[sizeof(B107)+1];
char b;
};
struct B107_extra_size var140;
#pragma pack(2)
typedef union {
char c;
A104 i __attribute__((packed));
} __attribute__((packed)) B108;
B108 var141;
#pragma pack()
struct B108_extra_alignment {
char a;
B108 b;
};
struct B108_extra_alignment var142;
#pragma pack(1)
struct B108_extra_packed {
B108 a;
};
#pragma pack()
struct B108_extra_required_alignment {
char a;
struct B108_extra_packed b;
};
struct B108_extra_required_alignment var143;
struct B108_extra_size {
char a[sizeof(B108)+1];
char b;
};
struct B108_extra_size var144;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A000) == 8, "");
_Static_assert(_Alignof(A000) == 4, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A000_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 10, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,i) == 32, "");
#endif
_Static_assert(sizeof(A001) == 5, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 7, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,i) == 8, "");
#endif
_Static_assert(sizeof(A002) == 5, "");
_Static_assert(_Alignof(A002) == 1, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 7, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,i) == 8, "");
#endif
_Static_assert(sizeof(A003) == 5, "");
_Static_assert(_Alignof(A003) == 1, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 7, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,i) == 8, "");
#endif
_Static_assert(sizeof(A004) == 4, "");
_Static_assert(_Alignof(A004) == 16, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 6, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 32, "");
_Static_assert(_Alignof(A005) == 16, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A005_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 34, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,i) == 128, "");
#endif
_Static_assert(sizeof(A006) == 5, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 7, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,i) == 8, "");
#endif
_Static_assert(sizeof(A007) == 5, "");
_Static_assert(_Alignof(A007) == 1, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 7, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,i) == 8, "");
#endif
_Static_assert(sizeof(A008) == 5, "");
_Static_assert(_Alignof(A008) == 1, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 7, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,i) == 8, "");
#endif
_Static_assert(sizeof(A100) == 6, "");
_Static_assert(_Alignof(A100) == 2, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A100_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 8, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,i) == 16, "");
#endif
_Static_assert(sizeof(A101) == 5, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 7, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,i) == 8, "");
#endif
_Static_assert(sizeof(A102) == 5, "");
_Static_assert(_Alignof(A102) == 1, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 7, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,i) == 8, "");
#endif
_Static_assert(sizeof(A103) == 5, "");
_Static_assert(_Alignof(A103) == 1, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 7, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,i) == 8, "");
#endif
_Static_assert(sizeof(A104) == 4, "");
_Static_assert(_Alignof(A104) == 16, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 6, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 6, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 8, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,i) == 16, "");
#endif
_Static_assert(sizeof(A106) == 5, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 7, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,i) == 8, "");
#endif
_Static_assert(sizeof(A107) == 5, "");
_Static_assert(_Alignof(A107) == 1, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 7, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,i) == 8, "");
#endif
_Static_assert(sizeof(A108) == 5, "");
_Static_assert(_Alignof(A108) == 1, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 7, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,i) == 8, "");
#endif
_Static_assert(sizeof(B000) == 4, "");
_Static_assert(_Alignof(B000) == 4, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 6, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,i) == 0, "");
#endif
_Static_assert(sizeof(B001) == 4, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 6, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,i) == 0, "");
#endif
_Static_assert(sizeof(B002) == 4, "");
_Static_assert(_Alignof(B002) == 1, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 6, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,i) == 0, "");
#endif
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 1, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,i) == 0, "");
#endif
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 16, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 16, "");
_Static_assert(_Alignof(B005) == 16, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B005_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 18, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,i) == 0, "");
#endif
_Static_assert(sizeof(B006) == 4, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 6, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,i) == 0, "");
#endif
_Static_assert(sizeof(B007) == 4, "");
_Static_assert(_Alignof(B007) == 1, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 6, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,i) == 0, "");
#endif
_Static_assert(sizeof(B008) == 4, "");
_Static_assert(_Alignof(B008) == 1, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 6, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,i) == 0, "");
#endif
_Static_assert(sizeof(B100) == 4, "");
_Static_assert(_Alignof(B100) == 2, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 6, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,i) == 0, "");
#endif
_Static_assert(sizeof(B101) == 4, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 6, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,i) == 0, "");
#endif
_Static_assert(sizeof(B102) == 4, "");
_Static_assert(_Alignof(B102) == 1, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 6, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,i) == 0, "");
#endif
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 1, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,i) == 0, "");
#endif
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 16, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 4, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 6, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,i) == 0, "");
#endif
_Static_assert(sizeof(B106) == 4, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 6, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,i) == 0, "");
#endif
_Static_assert(sizeof(B107) == 4, "");
_Static_assert(_Alignof(B107) == 1, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 6, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,i) == 0, "");
#endif
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 1, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,i) == 0, "");
#endif
// MAPPING|TWO|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A000) == 3, "");
_Static_assert(_Alignof(A000) == 1, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 5, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,i) == 8, "");
#endif
_Static_assert(sizeof(A001) == 3, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 5, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,i) == 8, "");
#endif
_Static_assert(sizeof(A002) == 3, "");
_Static_assert(_Alignof(A002) == 1, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 5, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,i) == 8, "");
#endif
_Static_assert(sizeof(A003) == 3, "");
_Static_assert(_Alignof(A003) == 1, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 5, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,i) == 8, "");
#endif
_Static_assert(sizeof(A004) == 2, "");
_Static_assert(_Alignof(A004) == 16, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A004_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 4, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 32, "");
_Static_assert(_Alignof(A005) == 16, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A005_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 34, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,i) == 128, "");
#endif
_Static_assert(sizeof(A006) == 3, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 5, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,i) == 8, "");
#endif
_Static_assert(sizeof(A007) == 3, "");
_Static_assert(_Alignof(A007) == 1, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 5, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,i) == 8, "");
#endif
_Static_assert(sizeof(A008) == 3, "");
_Static_assert(_Alignof(A008) == 1, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 5, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,i) == 8, "");
#endif
_Static_assert(sizeof(A100) == 3, "");
_Static_assert(_Alignof(A100) == 1, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 5, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,i) == 8, "");
#endif
_Static_assert(sizeof(A101) == 3, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 5, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,i) == 8, "");
#endif
_Static_assert(sizeof(A102) == 3, "");
_Static_assert(_Alignof(A102) == 1, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 5, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,i) == 8, "");
#endif
_Static_assert(sizeof(A103) == 3, "");
_Static_assert(_Alignof(A103) == 1, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 5, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,i) == 8, "");
#endif
_Static_assert(sizeof(A104) == 2, "");
_Static_assert(_Alignof(A104) == 16, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A104_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 4, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,i) == 16, "");
#endif
_Static_assert(sizeof(A106) == 3, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 5, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,i) == 8, "");
#endif
_Static_assert(sizeof(A107) == 3, "");
_Static_assert(_Alignof(A107) == 1, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 5, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,i) == 8, "");
#endif
_Static_assert(sizeof(A108) == 3, "");
_Static_assert(_Alignof(A108) == 1, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 5, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,i) == 8, "");
#endif
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 1, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,i) == 0, "");
#endif
_Static_assert(sizeof(B001) == 2, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 4, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,i) == 0, "");
#endif
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 1, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,i) == 0, "");
#endif
_Static_assert(sizeof(B003) == 2, "");
_Static_assert(_Alignof(B003) == 1, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 4, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,i) == 0, "");
#endif
_Static_assert(sizeof(B004) == 2, "");
_Static_assert(_Alignof(B004) == 16, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B004_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 4, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 16, "");
_Static_assert(_Alignof(B005) == 16, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B005_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 18, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,i) == 0, "");
#endif
_Static_assert(sizeof(B006) == 2, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 4, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,i) == 0, "");
#endif
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 1, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,i) == 0, "");
#endif
_Static_assert(sizeof(B008) == 2, "");
_Static_assert(_Alignof(B008) == 1, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 4, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,i) == 0, "");
#endif
_Static_assert(sizeof(B100) == 2, "");
_Static_assert(_Alignof(B100) == 1, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 4, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,i) == 0, "");
#endif
_Static_assert(sizeof(B101) == 2, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 4, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,i) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 1, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,i) == 0, "");
#endif
_Static_assert(sizeof(B103) == 2, "");
_Static_assert(_Alignof(B103) == 1, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 4, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,i) == 0, "");
#endif
_Static_assert(sizeof(B104) == 2, "");
_Static_assert(_Alignof(B104) == 16, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B104_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 4, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,i) == 0, "");
#endif
_Static_assert(sizeof(B106) == 2, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 4, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,i) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 1, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,i) == 0, "");
#endif
_Static_assert(sizeof(B108) == 2, "");
_Static_assert(_Alignof(B108) == 1, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 4, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,i) == 0, "");
#endif
// MAPPING|THREE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A000) == 4, "");
_Static_assert(_Alignof(A000) == 2, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 6, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,i) == 16, "");
#endif
_Static_assert(sizeof(A001) == 3, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 5, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,i) == 8, "");
#endif
_Static_assert(sizeof(A002) == 3, "");
_Static_assert(_Alignof(A002) == 1, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 5, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,i) == 8, "");
#endif
_Static_assert(sizeof(A003) == 3, "");
_Static_assert(_Alignof(A003) == 1, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 5, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,i) == 8, "");
#endif
_Static_assert(sizeof(A004) == 2, "");
_Static_assert(_Alignof(A004) == 16, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A004_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 4, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 32, "");
_Static_assert(_Alignof(A005) == 16, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A005_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 34, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,i) == 128, "");
#endif
_Static_assert(sizeof(A006) == 3, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 5, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,i) == 8, "");
#endif
_Static_assert(sizeof(A007) == 3, "");
_Static_assert(_Alignof(A007) == 1, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 5, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,i) == 8, "");
#endif
_Static_assert(sizeof(A008) == 3, "");
_Static_assert(_Alignof(A008) == 1, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 5, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,i) == 8, "");
#endif
_Static_assert(sizeof(A100) == 4, "");
_Static_assert(_Alignof(A100) == 2, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 6, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,i) == 16, "");
#endif
_Static_assert(sizeof(A101) == 3, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 5, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,i) == 8, "");
#endif
_Static_assert(sizeof(A102) == 3, "");
_Static_assert(_Alignof(A102) == 1, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 5, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,i) == 8, "");
#endif
_Static_assert(sizeof(A103) == 3, "");
_Static_assert(_Alignof(A103) == 1, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 5, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,i) == 8, "");
#endif
_Static_assert(sizeof(A104) == 2, "");
_Static_assert(_Alignof(A104) == 16, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A104_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 4, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,i) == 16, "");
#endif
_Static_assert(sizeof(A106) == 3, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 5, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,i) == 8, "");
#endif
_Static_assert(sizeof(A107) == 3, "");
_Static_assert(_Alignof(A107) == 1, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 5, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,i) == 8, "");
#endif
_Static_assert(sizeof(A108) == 3, "");
_Static_assert(_Alignof(A108) == 1, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 5, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,i) == 8, "");
#endif
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 2, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,i) == 0, "");
#endif
_Static_assert(sizeof(B001) == 2, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 4, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,i) == 0, "");
#endif
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 1, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,i) == 0, "");
#endif
_Static_assert(sizeof(B003) == 2, "");
_Static_assert(_Alignof(B003) == 1, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 4, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,i) == 0, "");
#endif
_Static_assert(sizeof(B004) == 2, "");
_Static_assert(_Alignof(B004) == 16, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B004_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 4, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 16, "");
_Static_assert(_Alignof(B005) == 16, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B005_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 18, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,i) == 0, "");
#endif
_Static_assert(sizeof(B006) == 2, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 4, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,i) == 0, "");
#endif
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 1, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,i) == 0, "");
#endif
_Static_assert(sizeof(B008) == 2, "");
_Static_assert(_Alignof(B008) == 1, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 4, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,i) == 0, "");
#endif
_Static_assert(sizeof(B100) == 2, "");
_Static_assert(_Alignof(B100) == 2, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B100_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 4, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,i) == 0, "");
#endif
_Static_assert(sizeof(B101) == 2, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 4, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,i) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 1, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,i) == 0, "");
#endif
_Static_assert(sizeof(B103) == 2, "");
_Static_assert(_Alignof(B103) == 1, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 4, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,i) == 0, "");
#endif
_Static_assert(sizeof(B104) == 2, "");
_Static_assert(_Alignof(B104) == 16, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B104_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 4, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,i) == 0, "");
#endif
_Static_assert(sizeof(B106) == 2, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 4, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,i) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 1, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,i) == 0, "");
#endif
_Static_assert(sizeof(B108) == 2, "");
_Static_assert(_Alignof(B108) == 1, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 4, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,i) == 0, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0055_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef enum {
F1 = 1,
} __attribute__((packed)) A;
A var2;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var3;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var4;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var5;
typedef enum {
F6 = 281474976710655,
} __attribute__((packed)) B;
B var7;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var8;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var9;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var10;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-i686-windows-gnu:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I686PcWindowsGnu|Some("x86-i686-windows-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(THREE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0077_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
#ifdef MSVC
__declspec(align(8)) int i:1;
#else
int i:1 __attribute__((aligned(8)));
#endif
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
#ifdef MSVC
__declspec(align(1)) int i:1;
#else
int i:1 __attribute__((aligned(1)));
#endif
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
typedef union {
#ifdef MSVC
__declspec(align(8)) int i:1;
#else
int i:1 __attribute__((aligned(8)));
#endif
} C;
C var9;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
typedef union {
#ifdef MSVC
__declspec(align(1)) int i:1;
#else
int i:1 __attribute__((aligned(1)));
#endif
} D;
D var13;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var14;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var15;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var16;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 4, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 6, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 4, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 6, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(THREE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0059_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c;
int:1 __attribute__((packed));
char d;
} __attribute__((packed)) A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
char c;
int:1 __attribute__((packed));
} __attribute__((packed)) B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 3, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 5, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 16, "");
#endif
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 6, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 8, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 40, "");
#endif
_Static_assert(sizeof(B) == 5, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 5, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 7, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 3, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 5, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 16, "");
#endif
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FOUR|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 3, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 5, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 16, "");
#endif
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0004_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
#ifdef MSVC
__declspec(align(2)) int a;
#else
int a __attribute__((aligned(2)));
#endif
} X;
X var1;
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var2;
#pragma pack(1)
struct X_extra_packed {
#ifdef MSVC
char a[sizeof(X)];
#else
X a;
#endif
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var3;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var4;
#pragma pack(1)
typedef struct {
X x;
} Y;
Y var5;
#pragma pack()
struct Y_extra_alignment {
char a;
Y b;
};
struct Y_extra_alignment var6;
#pragma pack(1)
struct Y_extra_packed {
#ifdef MSVC
char a[sizeof(Y)];
#else
Y a;
#endif
};
#pragma pack()
struct Y_extra_required_alignment {
char a;
struct Y_extra_packed b;
};
struct Y_extra_required_alignment var7;
struct Y_extra_size {
char a[sizeof(Y)+1];
char b;
};
struct Y_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(X) == 4, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 4, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 6, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 4, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 6, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(X) == 4, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 4, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 6, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 4, "");
_Static_assert(_Alignof(Y) == 2, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 2, "");
_Static_assert(sizeof(struct Y_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 6, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(X) == 2, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 2, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 4, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|FOUR|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(X) == 2, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 2, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 4, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0043_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
typedef int unnamed_type_1[];
#else
typedef int unnamed_type_1[0];
#endif
unnamed_type_1 var2;
struct unnamed_type_1_extra_alignment {
char a;
unnamed_type_1 b;
};
struct unnamed_type_1_extra_alignment var3;
#pragma pack(1)
struct unnamed_type_1_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_1)];
#else
unnamed_type_1 a;
#endif
};
#pragma pack()
struct unnamed_type_1_extra_required_alignment {
char a;
struct unnamed_type_1_extra_packed b;
};
struct unnamed_type_1_extra_required_alignment var4;
struct unnamed_type_1_extra_size {
char a[sizeof(unnamed_type_1)+1];
char b;
};
struct unnamed_type_1_extra_size var5;
typedef struct {
unnamed_type_1 FlexArrayMemb;
} EmptyIntMemb;
EmptyIntMemb var6;
struct EmptyIntMemb_extra_alignment {
char a;
EmptyIntMemb b;
};
struct EmptyIntMemb_extra_alignment var7;
#pragma pack(1)
struct EmptyIntMemb_extra_packed {
#ifdef MSVC
char a[sizeof(EmptyIntMemb)];
#else
EmptyIntMemb a;
#endif
};
#pragma pack()
struct EmptyIntMemb_extra_required_alignment {
char a;
struct EmptyIntMemb_extra_packed b;
};
struct EmptyIntMemb_extra_required_alignment var8;
struct EmptyIntMemb_extra_size {
char a[sizeof(EmptyIntMemb)+1];
char b;
};
struct EmptyIntMemb_extra_size var9;
#ifdef MSVC
typedef long long unnamed_type_10[];
#else
typedef long long unnamed_type_10[0];
#endif
unnamed_type_10 var11;
struct unnamed_type_10_extra_alignment {
char a;
unnamed_type_10 b;
};
struct unnamed_type_10_extra_alignment var12;
#pragma pack(1)
struct unnamed_type_10_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_10)];
#else
unnamed_type_10 a;
#endif
};
#pragma pack()
struct unnamed_type_10_extra_required_alignment {
char a;
struct unnamed_type_10_extra_packed b;
};
struct unnamed_type_10_extra_required_alignment var13;
struct unnamed_type_10_extra_size {
char a[sizeof(unnamed_type_10)+1];
char b;
};
struct unnamed_type_10_extra_size var14;
typedef struct {
unnamed_type_10 FlexArrayMemb;
} EmptyLongLongMemb;
EmptyLongLongMemb var15;
struct EmptyLongLongMemb_extra_alignment {
char a;
EmptyLongLongMemb b;
};
struct EmptyLongLongMemb_extra_alignment var16;
#pragma pack(1)
struct EmptyLongLongMemb_extra_packed {
#ifdef MSVC
char a[sizeof(EmptyLongLongMemb)];
#else
EmptyLongLongMemb a;
#endif
};
#pragma pack()
struct EmptyLongLongMemb_extra_required_alignment {
char a;
struct EmptyLongLongMemb_extra_packed b;
};
struct EmptyLongLongMemb_extra_required_alignment var17;
struct EmptyLongLongMemb_extra_size {
char a[sizeof(EmptyLongLongMemb)+1];
char b;
};
struct EmptyLongLongMemb_extra_size var18;
#ifdef MSVC
typedef long long unnamed_type_19[];
#else
typedef long long unnamed_type_19[0];
#endif
unnamed_type_19 var20;
struct unnamed_type_19_extra_alignment {
char a;
unnamed_type_19 b;
};
struct unnamed_type_19_extra_alignment var21;
#pragma pack(1)
struct unnamed_type_19_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_19)];
#else
unnamed_type_19 a;
#endif
};
#pragma pack()
struct unnamed_type_19_extra_required_alignment {
char a;
struct unnamed_type_19_extra_packed b;
};
struct unnamed_type_19_extra_required_alignment var22;
struct unnamed_type_19_extra_size {
char a[sizeof(unnamed_type_19)+1];
char b;
};
struct unnamed_type_19_extra_size var23;
typedef struct {
#ifdef MSVC
__declspec(align(2)) unnamed_type_19 FlexArrayMemb;
#else
unnamed_type_19 FlexArrayMemb __attribute__((aligned(2)));
#endif
} EmptyAligned2LongLongMemb;
EmptyAligned2LongLongMemb var24;
struct EmptyAligned2LongLongMemb_extra_alignment {
char a;
EmptyAligned2LongLongMemb b;
};
struct EmptyAligned2LongLongMemb_extra_alignment var25;
#pragma pack(1)
struct EmptyAligned2LongLongMemb_extra_packed {
#ifdef MSVC
char a[sizeof(EmptyAligned2LongLongMemb)];
#else
EmptyAligned2LongLongMemb a;
#endif
};
#pragma pack()
struct EmptyAligned2LongLongMemb_extra_required_alignment {
char a;
struct EmptyAligned2LongLongMemb_extra_packed b;
};
struct EmptyAligned2LongLongMemb_extra_required_alignment var26;
struct EmptyAligned2LongLongMemb_extra_size {
char a[sizeof(EmptyAligned2LongLongMemb)+1];
char b;
};
struct EmptyAligned2LongLongMemb_extra_size var27;
#ifdef MSVC
typedef long long unnamed_type_28[];
#else
typedef long long unnamed_type_28[0];
#endif
unnamed_type_28 var29;
struct unnamed_type_28_extra_alignment {
char a;
unnamed_type_28 b;
};
struct unnamed_type_28_extra_alignment var30;
#pragma pack(1)
struct unnamed_type_28_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_28)];
#else
unnamed_type_28 a;
#endif
};
#pragma pack()
struct unnamed_type_28_extra_required_alignment {
char a;
struct unnamed_type_28_extra_packed b;
};
struct unnamed_type_28_extra_required_alignment var31;
struct unnamed_type_28_extra_size {
char a[sizeof(unnamed_type_28)+1];
char b;
};
struct unnamed_type_28_extra_size var32;
typedef struct {
#ifdef MSVC
__declspec(align(8)) unnamed_type_28 FlexArrayMemb;
#else
unnamed_type_28 FlexArrayMemb __attribute__((aligned(8)));
#endif
} EmptyAligned8LongLongMemb;
EmptyAligned8LongLongMemb var33;
struct EmptyAligned8LongLongMemb_extra_alignment {
char a;
EmptyAligned8LongLongMemb b;
};
struct EmptyAligned8LongLongMemb_extra_alignment var34;
#pragma pack(1)
struct EmptyAligned8LongLongMemb_extra_packed {
#ifdef MSVC
char a[sizeof(EmptyAligned8LongLongMemb)];
#else
EmptyAligned8LongLongMemb a;
#endif
};
#pragma pack()
struct EmptyAligned8LongLongMemb_extra_required_alignment {
char a;
struct EmptyAligned8LongLongMemb_extra_packed b;
};
struct EmptyAligned8LongLongMemb_extra_required_alignment var35;
struct EmptyAligned8LongLongMemb_extra_size {
char a[sizeof(EmptyAligned8LongLongMemb)+1];
char b;
};
struct EmptyAligned8LongLongMemb_extra_size var36;
#ifdef MSVC
typedef long long unnamed_type_37[];
#else
typedef long long unnamed_type_37[0];
#endif
unnamed_type_37 var38;
struct unnamed_type_37_extra_alignment {
char a;
unnamed_type_37 b;
};
struct unnamed_type_37_extra_alignment var39;
#pragma pack(1)
struct unnamed_type_37_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_37)];
#else
unnamed_type_37 a;
#endif
};
#pragma pack()
struct unnamed_type_37_extra_required_alignment {
char a;
struct unnamed_type_37_extra_packed b;
};
struct unnamed_type_37_extra_required_alignment var40;
struct unnamed_type_37_extra_size {
char a[sizeof(unnamed_type_37)+1];
char b;
};
struct unnamed_type_37_extra_size var41;
#pragma pack(1)
#ifdef MSVC
__declspec(align(4)) typedef struct {
#else
typedef struct {
#endif
unnamed_type_37 FlexArrayMemb;
#ifdef MSVC
} EmptyPackedAligned4LongLongMemb;
#else
} __attribute__((aligned(4))) EmptyPackedAligned4LongLongMemb;
#endif
EmptyPackedAligned4LongLongMemb var42;
#pragma pack()
struct EmptyPackedAligned4LongLongMemb_extra_alignment {
char a;
EmptyPackedAligned4LongLongMemb b;
};
struct EmptyPackedAligned4LongLongMemb_extra_alignment var43;
#pragma pack(1)
struct EmptyPackedAligned4LongLongMemb_extra_packed {
#ifdef MSVC
char a[sizeof(EmptyPackedAligned4LongLongMemb)];
#else
EmptyPackedAligned4LongLongMemb a;
#endif
};
#pragma pack()
struct EmptyPackedAligned4LongLongMemb_extra_required_alignment {
char a;
struct EmptyPackedAligned4LongLongMemb_extra_packed b;
};
struct EmptyPackedAligned4LongLongMemb_extra_required_alignment var44;
struct EmptyPackedAligned4LongLongMemb_extra_size {
char a[sizeof(EmptyPackedAligned4LongLongMemb)+1];
char b;
};
struct EmptyPackedAligned4LongLongMemb_extra_size var45;
#ifdef MSVC
typedef long long unnamed_type_46[];
#else
typedef long long unnamed_type_46[0];
#endif
unnamed_type_46 var47;
struct unnamed_type_46_extra_alignment {
char a;
unnamed_type_46 b;
};
struct unnamed_type_46_extra_alignment var48;
#pragma pack(1)
struct unnamed_type_46_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_46)];
#else
unnamed_type_46 a;
#endif
};
#pragma pack()
struct unnamed_type_46_extra_required_alignment {
char a;
struct unnamed_type_46_extra_packed b;
};
struct unnamed_type_46_extra_required_alignment var49;
struct unnamed_type_46_extra_size {
char a[sizeof(unnamed_type_46)+1];
char b;
};
struct unnamed_type_46_extra_size var50;
#pragma pack(1)
typedef struct {
#ifdef MSVC
__declspec(align(8)) unnamed_type_46 FlexArrayMemb;
#else
unnamed_type_46 FlexArrayMemb __attribute__((aligned(8)));
#endif
} EmptyPackedAligned8LongLongMemb;
EmptyPackedAligned8LongLongMemb var51;
#pragma pack()
struct EmptyPackedAligned8LongLongMemb_extra_alignment {
char a;
EmptyPackedAligned8LongLongMemb b;
};
struct EmptyPackedAligned8LongLongMemb_extra_alignment var52;
#pragma pack(1)
struct EmptyPackedAligned8LongLongMemb_extra_packed {
#ifdef MSVC
char a[sizeof(EmptyPackedAligned8LongLongMemb)];
#else
EmptyPackedAligned8LongLongMemb a;
#endif
};
#pragma pack()
struct EmptyPackedAligned8LongLongMemb_extra_required_alignment {
char a;
struct EmptyPackedAligned8LongLongMemb_extra_packed b;
};
struct EmptyPackedAligned8LongLongMemb_extra_required_alignment var53;
struct EmptyPackedAligned8LongLongMemb_extra_size {
char a[sizeof(EmptyPackedAligned8LongLongMemb)+1];
char b;
};
struct EmptyPackedAligned8LongLongMemb_extra_size var54;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-i686-windows-gnu:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I686PcWindowsGnu|Some("x86-i686-windows-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(EmptyIntMemb) == 0, "");
_Static_assert(_Alignof(EmptyIntMemb) == 4, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyLongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyAligned2LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAligned2LongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyAligned8LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAligned8LongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAligned4LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAligned4LongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAligned8LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAligned8LongLongMemb) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(EmptyIntMemb) == 4, "");
_Static_assert(_Alignof(EmptyIntMemb) == 4, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_packed) == 4, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_size) == 6, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyLongLongMemb) == 4, "");
_Static_assert(_Alignof(EmptyLongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_packed) == 4, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_size) == 6, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyAligned2LongLongMemb) == 4, "");
_Static_assert(_Alignof(EmptyAligned2LongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_packed) == 4, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_size) == 6, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyAligned8LongLongMemb) == 8, "");
_Static_assert(_Alignof(EmptyAligned8LongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_packed) == 8, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_size) == 10, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAligned4LongLongMemb) == 4, "");
_Static_assert(_Alignof(EmptyPackedAligned4LongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_packed) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_size) == 6, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAligned8LongLongMemb) == 8, "");
_Static_assert(_Alignof(EmptyPackedAligned8LongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_packed) == 8, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_size) == 10, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(THREE)
_Static_assert(sizeof(EmptyIntMemb) == 0, "");
_Static_assert(_Alignof(EmptyIntMemb) == 4, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyAligned2LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAligned2LongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyAligned8LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAligned8LongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAligned4LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAligned4LongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAligned8LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAligned8LongLongMemb) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(EmptyIntMemb) == 0, "");
_Static_assert(_Alignof(EmptyIntMemb) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyLongLongMemb) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyAligned2LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAligned2LongLongMemb) == 2, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_alignment) == 2, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyAligned8LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAligned8LongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAligned4LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAligned4LongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAligned8LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAligned8LongLongMemb) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_size) == 1, "");
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(EmptyIntMemb) == 0, "");
_Static_assert(_Alignof(EmptyIntMemb) == 2, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_alignment) == 2, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyIntMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyIntMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyLongLongMemb) == 2, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_alignment) == 2, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyAligned2LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAligned2LongLongMemb) == 2, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_alignment) == 2, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAligned2LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAligned2LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyAligned8LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAligned8LongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAligned8LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAligned8LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAligned4LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAligned4LongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned4LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAligned4LongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAligned8LongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAligned8LongLongMemb) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAligned8LongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAligned8LongLongMemb_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0012_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(2)) typedef struct {
#else
typedef struct {
#endif
int a;
#ifdef MSVC
} X;
#else
} __attribute__((aligned(2))) X;
#endif
X var1;
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var2;
#pragma pack(1)
struct X_extra_packed {
#ifdef MSVC
char a[sizeof(X)];
#else
X a;
#endif
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var3;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var4;
#pragma pack(1)
typedef struct {
X x;
} Y;
Y var5;
#pragma pack()
struct Y_extra_alignment {
char a;
Y b;
};
struct Y_extra_alignment var6;
#pragma pack(1)
struct Y_extra_packed {
#ifdef MSVC
char a[sizeof(Y)];
#else
Y a;
#endif
};
#pragma pack()
struct Y_extra_required_alignment {
char a;
struct Y_extra_packed b;
};
struct Y_extra_required_alignment var7;
struct Y_extra_size {
char a[sizeof(Y)+1];
char b;
};
struct Y_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(X) == 4, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 4, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 6, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 4, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 6, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(X) == 4, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 4, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 6, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 4, "");
_Static_assert(_Alignof(Y) == 2, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 2, "");
_Static_assert(sizeof(struct Y_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 6, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(X) == 2, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 2, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 4, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|FOUR|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(X) == 2, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 2, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 4, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0047_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char a;
int:1;
char c;
} X;
X var1;
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var2;
#pragma pack(1)
struct X_extra_packed {
#ifdef MSVC
char a[sizeof(X)];
#else
X a;
#endif
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var3;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var4;
typedef struct {
char a;
char:0;
char c;
} Y;
Y var5;
struct Y_extra_alignment {
char a;
Y b;
};
struct Y_extra_alignment var6;
#pragma pack(1)
struct Y_extra_packed {
#ifdef MSVC
char a[sizeof(Y)];
#else
Y a;
#endif
};
#pragma pack()
struct Y_extra_required_alignment {
char a;
struct Y_extra_packed b;
};
struct Y_extra_required_alignment var7;
struct Y_extra_size {
char a[sizeof(Y)+1];
char b;
};
struct Y_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(X) == 3, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 3, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 5, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,c) == 16, "");
#endif
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,c) == 8, "");
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(X) == 4, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 4, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 6, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,c) == 16, "");
#endif
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,c) == 8, "");
#endif
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(THREE)
_Static_assert(sizeof(X) == 12, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 12, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 14, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,c) == 64, "");
#endif
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,c) == 8, "");
#endif
// MAPPING|FOUR|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(FOUR)
_Static_assert(sizeof(X) == 3, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 3, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 5, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,c) == 16, "");
#endif
_Static_assert(sizeof(Y) == 8, "");
_Static_assert(_Alignof(Y) == 4, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Y_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,c) == 32, "");
#endif
// MAPPING|FIVE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(X) == 3, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 3, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 5, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,c) == 16, "");
#endif
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,c) == 8, "");
#endif
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(X) == 3, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 3, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 5, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,c) == 16, "");
#endif
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,c) == 8, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0062_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef enum {
F1 = 0,
} __attribute__((packed)) A000;
A000 var2;
struct A000_extra_alignment {
char a;
A000 b;
};
struct A000_extra_alignment var3;
#pragma pack(1)
struct A000_extra_packed {
A000 a;
};
#pragma pack()
struct A000_extra_required_alignment {
char a;
struct A000_extra_packed b;
};
struct A000_extra_required_alignment var4;
struct A000_extra_size {
char a[sizeof(A000)+1];
char b;
};
struct A000_extra_size var5;
typedef enum {
F6 = 1,
} __attribute__((packed)) A001;
A001 var7;
struct A001_extra_alignment {
char a;
A001 b;
};
struct A001_extra_alignment var8;
#pragma pack(1)
struct A001_extra_packed {
A001 a;
};
#pragma pack()
struct A001_extra_required_alignment {
char a;
struct A001_extra_packed b;
};
struct A001_extra_required_alignment var9;
struct A001_extra_size {
char a[sizeof(A001)+1];
char b;
};
struct A001_extra_size var10;
typedef enum {
F11 = 2,
} __attribute__((packed)) A002;
A002 var12;
struct A002_extra_alignment {
char a;
A002 b;
};
struct A002_extra_alignment var13;
#pragma pack(1)
struct A002_extra_packed {
A002 a;
};
#pragma pack()
struct A002_extra_required_alignment {
char a;
struct A002_extra_packed b;
};
struct A002_extra_required_alignment var14;
struct A002_extra_size {
char a[sizeof(A002)+1];
char b;
};
struct A002_extra_size var15;
typedef enum {
F16 = 4,
} __attribute__((packed)) A003;
A003 var17;
struct A003_extra_alignment {
char a;
A003 b;
};
struct A003_extra_alignment var18;
#pragma pack(1)
struct A003_extra_packed {
A003 a;
};
#pragma pack()
struct A003_extra_required_alignment {
char a;
struct A003_extra_packed b;
};
struct A003_extra_required_alignment var19;
struct A003_extra_size {
char a[sizeof(A003)+1];
char b;
};
struct A003_extra_size var20;
typedef enum {
F21 = 8,
} __attribute__((packed)) A004;
A004 var22;
struct A004_extra_alignment {
char a;
A004 b;
};
struct A004_extra_alignment var23;
#pragma pack(1)
struct A004_extra_packed {
A004 a;
};
#pragma pack()
struct A004_extra_required_alignment {
char a;
struct A004_extra_packed b;
};
struct A004_extra_required_alignment var24;
struct A004_extra_size {
char a[sizeof(A004)+1];
char b;
};
struct A004_extra_size var25;
typedef enum {
F26 = 16,
} __attribute__((packed)) A005;
A005 var27;
struct A005_extra_alignment {
char a;
A005 b;
};
struct A005_extra_alignment var28;
#pragma pack(1)
struct A005_extra_packed {
A005 a;
};
#pragma pack()
struct A005_extra_required_alignment {
char a;
struct A005_extra_packed b;
};
struct A005_extra_required_alignment var29;
struct A005_extra_size {
char a[sizeof(A005)+1];
char b;
};
struct A005_extra_size var30;
typedef enum {
F31 = 32,
} __attribute__((packed)) A006;
A006 var32;
struct A006_extra_alignment {
char a;
A006 b;
};
struct A006_extra_alignment var33;
#pragma pack(1)
struct A006_extra_packed {
A006 a;
};
#pragma pack()
struct A006_extra_required_alignment {
char a;
struct A006_extra_packed b;
};
struct A006_extra_required_alignment var34;
struct A006_extra_size {
char a[sizeof(A006)+1];
char b;
};
struct A006_extra_size var35;
typedef enum {
F36 = 64,
} __attribute__((packed)) A007;
A007 var37;
struct A007_extra_alignment {
char a;
A007 b;
};
struct A007_extra_alignment var38;
#pragma pack(1)
struct A007_extra_packed {
A007 a;
};
#pragma pack()
struct A007_extra_required_alignment {
char a;
struct A007_extra_packed b;
};
struct A007_extra_required_alignment var39;
struct A007_extra_size {
char a[sizeof(A007)+1];
char b;
};
struct A007_extra_size var40;
typedef enum {
F41 = 128,
} __attribute__((packed)) A008;
A008 var42;
struct A008_extra_alignment {
char a;
A008 b;
};
struct A008_extra_alignment var43;
#pragma pack(1)
struct A008_extra_packed {
A008 a;
};
#pragma pack()
struct A008_extra_required_alignment {
char a;
struct A008_extra_packed b;
};
struct A008_extra_required_alignment var44;
struct A008_extra_size {
char a[sizeof(A008)+1];
char b;
};
struct A008_extra_size var45;
typedef enum {
F46 = 256,
} __attribute__((packed)) A009;
A009 var47;
struct A009_extra_alignment {
char a;
A009 b;
};
struct A009_extra_alignment var48;
#pragma pack(1)
struct A009_extra_packed {
A009 a;
};
#pragma pack()
struct A009_extra_required_alignment {
char a;
struct A009_extra_packed b;
};
struct A009_extra_required_alignment var49;
struct A009_extra_size {
char a[sizeof(A009)+1];
char b;
};
struct A009_extra_size var50;
typedef enum {
F51 = 512,
} __attribute__((packed)) A010;
A010 var52;
struct A010_extra_alignment {
char a;
A010 b;
};
struct A010_extra_alignment var53;
#pragma pack(1)
struct A010_extra_packed {
A010 a;
};
#pragma pack()
struct A010_extra_required_alignment {
char a;
struct A010_extra_packed b;
};
struct A010_extra_required_alignment var54;
struct A010_extra_size {
char a[sizeof(A010)+1];
char b;
};
struct A010_extra_size var55;
typedef enum {
F56 = 1024,
} __attribute__((packed)) A011;
A011 var57;
struct A011_extra_alignment {
char a;
A011 b;
};
struct A011_extra_alignment var58;
#pragma pack(1)
struct A011_extra_packed {
A011 a;
};
#pragma pack()
struct A011_extra_required_alignment {
char a;
struct A011_extra_packed b;
};
struct A011_extra_required_alignment var59;
struct A011_extra_size {
char a[sizeof(A011)+1];
char b;
};
struct A011_extra_size var60;
typedef enum {
F61 = 2048,
} __attribute__((packed)) A012;
A012 var62;
struct A012_extra_alignment {
char a;
A012 b;
};
struct A012_extra_alignment var63;
#pragma pack(1)
struct A012_extra_packed {
A012 a;
};
#pragma pack()
struct A012_extra_required_alignment {
char a;
struct A012_extra_packed b;
};
struct A012_extra_required_alignment var64;
struct A012_extra_size {
char a[sizeof(A012)+1];
char b;
};
struct A012_extra_size var65;
typedef enum {
F66 = 4096,
} __attribute__((packed)) A013;
A013 var67;
struct A013_extra_alignment {
char a;
A013 b;
};
struct A013_extra_alignment var68;
#pragma pack(1)
struct A013_extra_packed {
A013 a;
};
#pragma pack()
struct A013_extra_required_alignment {
char a;
struct A013_extra_packed b;
};
struct A013_extra_required_alignment var69;
struct A013_extra_size {
char a[sizeof(A013)+1];
char b;
};
struct A013_extra_size var70;
typedef enum {
F71 = 8192,
} __attribute__((packed)) A014;
A014 var72;
struct A014_extra_alignment {
char a;
A014 b;
};
struct A014_extra_alignment var73;
#pragma pack(1)
struct A014_extra_packed {
A014 a;
};
#pragma pack()
struct A014_extra_required_alignment {
char a;
struct A014_extra_packed b;
};
struct A014_extra_required_alignment var74;
struct A014_extra_size {
char a[sizeof(A014)+1];
char b;
};
struct A014_extra_size var75;
typedef enum {
F76 = 16384,
} __attribute__((packed)) A015;
A015 var77;
struct A015_extra_alignment {
char a;
A015 b;
};
struct A015_extra_alignment var78;
#pragma pack(1)
struct A015_extra_packed {
A015 a;
};
#pragma pack()
struct A015_extra_required_alignment {
char a;
struct A015_extra_packed b;
};
struct A015_extra_required_alignment var79;
struct A015_extra_size {
char a[sizeof(A015)+1];
char b;
};
struct A015_extra_size var80;
typedef enum {
F81 = 32768,
} __attribute__((packed)) A016;
A016 var82;
struct A016_extra_alignment {
char a;
A016 b;
};
struct A016_extra_alignment var83;
#pragma pack(1)
struct A016_extra_packed {
A016 a;
};
#pragma pack()
struct A016_extra_required_alignment {
char a;
struct A016_extra_packed b;
};
struct A016_extra_required_alignment var84;
struct A016_extra_size {
char a[sizeof(A016)+1];
char b;
};
struct A016_extra_size var85;
typedef enum {
F86 = 65536,
} __attribute__((packed)) A021;
A021 var87;
struct A021_extra_alignment {
char a;
A021 b;
};
struct A021_extra_alignment var88;
#pragma pack(1)
struct A021_extra_packed {
A021 a;
};
#pragma pack()
struct A021_extra_required_alignment {
char a;
struct A021_extra_packed b;
};
struct A021_extra_required_alignment var89;
struct A021_extra_size {
char a[sizeof(A021)+1];
char b;
};
struct A021_extra_size var90;
typedef enum {
F91 = 131072,
} __attribute__((packed)) A022;
A022 var92;
struct A022_extra_alignment {
char a;
A022 b;
};
struct A022_extra_alignment var93;
#pragma pack(1)
struct A022_extra_packed {
A022 a;
};
#pragma pack()
struct A022_extra_required_alignment {
char a;
struct A022_extra_packed b;
};
struct A022_extra_required_alignment var94;
struct A022_extra_size {
char a[sizeof(A022)+1];
char b;
};
struct A022_extra_size var95;
typedef enum {
F96 = 262144,
} __attribute__((packed)) A023;
A023 var97;
struct A023_extra_alignment {
char a;
A023 b;
};
struct A023_extra_alignment var98;
#pragma pack(1)
struct A023_extra_packed {
A023 a;
};
#pragma pack()
struct A023_extra_required_alignment {
char a;
struct A023_extra_packed b;
};
struct A023_extra_required_alignment var99;
struct A023_extra_size {
char a[sizeof(A023)+1];
char b;
};
struct A023_extra_size var100;
typedef enum {
F101 = 524288,
} __attribute__((packed)) A024;
A024 var102;
struct A024_extra_alignment {
char a;
A024 b;
};
struct A024_extra_alignment var103;
#pragma pack(1)
struct A024_extra_packed {
A024 a;
};
#pragma pack()
struct A024_extra_required_alignment {
char a;
struct A024_extra_packed b;
};
struct A024_extra_required_alignment var104;
struct A024_extra_size {
char a[sizeof(A024)+1];
char b;
};
struct A024_extra_size var105;
typedef enum {
F106 = 1048576,
} __attribute__((packed)) A025;
A025 var107;
struct A025_extra_alignment {
char a;
A025 b;
};
struct A025_extra_alignment var108;
#pragma pack(1)
struct A025_extra_packed {
A025 a;
};
#pragma pack()
struct A025_extra_required_alignment {
char a;
struct A025_extra_packed b;
};
struct A025_extra_required_alignment var109;
struct A025_extra_size {
char a[sizeof(A025)+1];
char b;
};
struct A025_extra_size var110;
typedef enum {
F111 = 2097152,
} __attribute__((packed)) A026;
A026 var112;
struct A026_extra_alignment {
char a;
A026 b;
};
struct A026_extra_alignment var113;
#pragma pack(1)
struct A026_extra_packed {
A026 a;
};
#pragma pack()
struct A026_extra_required_alignment {
char a;
struct A026_extra_packed b;
};
struct A026_extra_required_alignment var114;
struct A026_extra_size {
char a[sizeof(A026)+1];
char b;
};
struct A026_extra_size var115;
typedef enum {
F116 = 4194304,
} __attribute__((packed)) A027;
A027 var117;
struct A027_extra_alignment {
char a;
A027 b;
};
struct A027_extra_alignment var118;
#pragma pack(1)
struct A027_extra_packed {
A027 a;
};
#pragma pack()
struct A027_extra_required_alignment {
char a;
struct A027_extra_packed b;
};
struct A027_extra_required_alignment var119;
struct A027_extra_size {
char a[sizeof(A027)+1];
char b;
};
struct A027_extra_size var120;
typedef enum {
F121 = 8388608,
} __attribute__((packed)) A028;
A028 var122;
struct A028_extra_alignment {
char a;
A028 b;
};
struct A028_extra_alignment var123;
#pragma pack(1)
struct A028_extra_packed {
A028 a;
};
#pragma pack()
struct A028_extra_required_alignment {
char a;
struct A028_extra_packed b;
};
struct A028_extra_required_alignment var124;
struct A028_extra_size {
char a[sizeof(A028)+1];
char b;
};
struct A028_extra_size var125;
typedef enum {
F126 = 16777216,
} __attribute__((packed)) A029;
A029 var127;
struct A029_extra_alignment {
char a;
A029 b;
};
struct A029_extra_alignment var128;
#pragma pack(1)
struct A029_extra_packed {
A029 a;
};
#pragma pack()
struct A029_extra_required_alignment {
char a;
struct A029_extra_packed b;
};
struct A029_extra_required_alignment var129;
struct A029_extra_size {
char a[sizeof(A029)+1];
char b;
};
struct A029_extra_size var130;
typedef enum {
F131 = 33554432,
} __attribute__((packed)) A030;
A030 var132;
struct A030_extra_alignment {
char a;
A030 b;
};
struct A030_extra_alignment var133;
#pragma pack(1)
struct A030_extra_packed {
A030 a;
};
#pragma pack()
struct A030_extra_required_alignment {
char a;
struct A030_extra_packed b;
};
struct A030_extra_required_alignment var134;
struct A030_extra_size {
char a[sizeof(A030)+1];
char b;
};
struct A030_extra_size var135;
typedef enum {
F136 = 67108864,
} __attribute__((packed)) A031;
A031 var137;
struct A031_extra_alignment {
char a;
A031 b;
};
struct A031_extra_alignment var138;
#pragma pack(1)
struct A031_extra_packed {
A031 a;
};
#pragma pack()
struct A031_extra_required_alignment {
char a;
struct A031_extra_packed b;
};
struct A031_extra_required_alignment var139;
struct A031_extra_size {
char a[sizeof(A031)+1];
char b;
};
struct A031_extra_size var140;
typedef enum {
F141 = 134217728,
} __attribute__((packed)) A032;
A032 var142;
struct A032_extra_alignment {
char a;
A032 b;
};
struct A032_extra_alignment var143;
#pragma pack(1)
struct A032_extra_packed {
A032 a;
};
#pragma pack()
struct A032_extra_required_alignment {
char a;
struct A032_extra_packed b;
};
struct A032_extra_required_alignment var144;
struct A032_extra_size {
char a[sizeof(A032)+1];
char b;
};
struct A032_extra_size var145;
typedef enum {
F146 = 268435456,
} __attribute__((packed)) A033;
A033 var147;
struct A033_extra_alignment {
char a;
A033 b;
};
struct A033_extra_alignment var148;
#pragma pack(1)
struct A033_extra_packed {
A033 a;
};
#pragma pack()
struct A033_extra_required_alignment {
char a;
struct A033_extra_packed b;
};
struct A033_extra_required_alignment var149;
struct A033_extra_size {
char a[sizeof(A033)+1];
char b;
};
struct A033_extra_size var150;
typedef enum {
F151 = 536870912,
} __attribute__((packed)) A034;
A034 var152;
struct A034_extra_alignment {
char a;
A034 b;
};
struct A034_extra_alignment var153;
#pragma pack(1)
struct A034_extra_packed {
A034 a;
};
#pragma pack()
struct A034_extra_required_alignment {
char a;
struct A034_extra_packed b;
};
struct A034_extra_required_alignment var154;
struct A034_extra_size {
char a[sizeof(A034)+1];
char b;
};
struct A034_extra_size var155;
typedef enum {
F156 = 1073741824,
} __attribute__((packed)) A035;
A035 var157;
struct A035_extra_alignment {
char a;
A035 b;
};
struct A035_extra_alignment var158;
#pragma pack(1)
struct A035_extra_packed {
A035 a;
};
#pragma pack()
struct A035_extra_required_alignment {
char a;
struct A035_extra_packed b;
};
struct A035_extra_required_alignment var159;
struct A035_extra_size {
char a[sizeof(A035)+1];
char b;
};
struct A035_extra_size var160;
typedef enum {
F161 = 2147483648,
} __attribute__((packed)) A036;
A036 var162;
struct A036_extra_alignment {
char a;
A036 b;
};
struct A036_extra_alignment var163;
#pragma pack(1)
struct A036_extra_packed {
A036 a;
};
#pragma pack()
struct A036_extra_required_alignment {
char a;
struct A036_extra_packed b;
};
struct A036_extra_required_alignment var164;
struct A036_extra_size {
char a[sizeof(A036)+1];
char b;
};
struct A036_extra_size var165;
typedef enum {
F166 = 4294967296,
} __attribute__((packed)) A041;
A041 var167;
struct A041_extra_alignment {
char a;
A041 b;
};
struct A041_extra_alignment var168;
#pragma pack(1)
struct A041_extra_packed {
A041 a;
};
#pragma pack()
struct A041_extra_required_alignment {
char a;
struct A041_extra_packed b;
};
struct A041_extra_required_alignment var169;
struct A041_extra_size {
char a[sizeof(A041)+1];
char b;
};
struct A041_extra_size var170;
typedef enum {
F171 = 8589934592,
} __attribute__((packed)) A042;
A042 var172;
struct A042_extra_alignment {
char a;
A042 b;
};
struct A042_extra_alignment var173;
#pragma pack(1)
struct A042_extra_packed {
A042 a;
};
#pragma pack()
struct A042_extra_required_alignment {
char a;
struct A042_extra_packed b;
};
struct A042_extra_required_alignment var174;
struct A042_extra_size {
char a[sizeof(A042)+1];
char b;
};
struct A042_extra_size var175;
typedef enum {
F176 = 17179869184,
} __attribute__((packed)) A043;
A043 var177;
struct A043_extra_alignment {
char a;
A043 b;
};
struct A043_extra_alignment var178;
#pragma pack(1)
struct A043_extra_packed {
A043 a;
};
#pragma pack()
struct A043_extra_required_alignment {
char a;
struct A043_extra_packed b;
};
struct A043_extra_required_alignment var179;
struct A043_extra_size {
char a[sizeof(A043)+1];
char b;
};
struct A043_extra_size var180;
typedef enum {
F181 = 34359738368,
} __attribute__((packed)) A044;
A044 var182;
struct A044_extra_alignment {
char a;
A044 b;
};
struct A044_extra_alignment var183;
#pragma pack(1)
struct A044_extra_packed {
A044 a;
};
#pragma pack()
struct A044_extra_required_alignment {
char a;
struct A044_extra_packed b;
};
struct A044_extra_required_alignment var184;
struct A044_extra_size {
char a[sizeof(A044)+1];
char b;
};
struct A044_extra_size var185;
typedef enum {
F186 = 68719476736,
} __attribute__((packed)) A045;
A045 var187;
struct A045_extra_alignment {
char a;
A045 b;
};
struct A045_extra_alignment var188;
#pragma pack(1)
struct A045_extra_packed {
A045 a;
};
#pragma pack()
struct A045_extra_required_alignment {
char a;
struct A045_extra_packed b;
};
struct A045_extra_required_alignment var189;
struct A045_extra_size {
char a[sizeof(A045)+1];
char b;
};
struct A045_extra_size var190;
typedef enum {
F191 = 137438953472,
} __attribute__((packed)) A046;
A046 var192;
struct A046_extra_alignment {
char a;
A046 b;
};
struct A046_extra_alignment var193;
#pragma pack(1)
struct A046_extra_packed {
A046 a;
};
#pragma pack()
struct A046_extra_required_alignment {
char a;
struct A046_extra_packed b;
};
struct A046_extra_required_alignment var194;
struct A046_extra_size {
char a[sizeof(A046)+1];
char b;
};
struct A046_extra_size var195;
typedef enum {
F196 = 274877906944,
} __attribute__((packed)) A047;
A047 var197;
struct A047_extra_alignment {
char a;
A047 b;
};
struct A047_extra_alignment var198;
#pragma pack(1)
struct A047_extra_packed {
A047 a;
};
#pragma pack()
struct A047_extra_required_alignment {
char a;
struct A047_extra_packed b;
};
struct A047_extra_required_alignment var199;
struct A047_extra_size {
char a[sizeof(A047)+1];
char b;
};
struct A047_extra_size var200;
typedef enum {
F201 = 549755813888,
} __attribute__((packed)) A048;
A048 var202;
struct A048_extra_alignment {
char a;
A048 b;
};
struct A048_extra_alignment var203;
#pragma pack(1)
struct A048_extra_packed {
A048 a;
};
#pragma pack()
struct A048_extra_required_alignment {
char a;
struct A048_extra_packed b;
};
struct A048_extra_required_alignment var204;
struct A048_extra_size {
char a[sizeof(A048)+1];
char b;
};
struct A048_extra_size var205;
typedef enum {
F206 = 1099511627776,
} __attribute__((packed)) A049;
A049 var207;
struct A049_extra_alignment {
char a;
A049 b;
};
struct A049_extra_alignment var208;
#pragma pack(1)
struct A049_extra_packed {
A049 a;
};
#pragma pack()
struct A049_extra_required_alignment {
char a;
struct A049_extra_packed b;
};
struct A049_extra_required_alignment var209;
struct A049_extra_size {
char a[sizeof(A049)+1];
char b;
};
struct A049_extra_size var210;
typedef enum {
F211 = 2199023255552,
} __attribute__((packed)) A050;
A050 var212;
struct A050_extra_alignment {
char a;
A050 b;
};
struct A050_extra_alignment var213;
#pragma pack(1)
struct A050_extra_packed {
A050 a;
};
#pragma pack()
struct A050_extra_required_alignment {
char a;
struct A050_extra_packed b;
};
struct A050_extra_required_alignment var214;
struct A050_extra_size {
char a[sizeof(A050)+1];
char b;
};
struct A050_extra_size var215;
typedef enum {
F216 = 4398046511104,
} __attribute__((packed)) A051;
A051 var217;
struct A051_extra_alignment {
char a;
A051 b;
};
struct A051_extra_alignment var218;
#pragma pack(1)
struct A051_extra_packed {
A051 a;
};
#pragma pack()
struct A051_extra_required_alignment {
char a;
struct A051_extra_packed b;
};
struct A051_extra_required_alignment var219;
struct A051_extra_size {
char a[sizeof(A051)+1];
char b;
};
struct A051_extra_size var220;
typedef enum {
F221 = 8796093022208,
} __attribute__((packed)) A052;
A052 var222;
struct A052_extra_alignment {
char a;
A052 b;
};
struct A052_extra_alignment var223;
#pragma pack(1)
struct A052_extra_packed {
A052 a;
};
#pragma pack()
struct A052_extra_required_alignment {
char a;
struct A052_extra_packed b;
};
struct A052_extra_required_alignment var224;
struct A052_extra_size {
char a[sizeof(A052)+1];
char b;
};
struct A052_extra_size var225;
typedef enum {
F226 = 17592186044416,
} __attribute__((packed)) A053;
A053 var227;
struct A053_extra_alignment {
char a;
A053 b;
};
struct A053_extra_alignment var228;
#pragma pack(1)
struct A053_extra_packed {
A053 a;
};
#pragma pack()
struct A053_extra_required_alignment {
char a;
struct A053_extra_packed b;
};
struct A053_extra_required_alignment var229;
struct A053_extra_size {
char a[sizeof(A053)+1];
char b;
};
struct A053_extra_size var230;
typedef enum {
F231 = 35184372088832,
} __attribute__((packed)) A054;
A054 var232;
struct A054_extra_alignment {
char a;
A054 b;
};
struct A054_extra_alignment var233;
#pragma pack(1)
struct A054_extra_packed {
A054 a;
};
#pragma pack()
struct A054_extra_required_alignment {
char a;
struct A054_extra_packed b;
};
struct A054_extra_required_alignment var234;
struct A054_extra_size {
char a[sizeof(A054)+1];
char b;
};
struct A054_extra_size var235;
typedef enum {
F236 = 70368744177664,
} __attribute__((packed)) A055;
A055 var237;
struct A055_extra_alignment {
char a;
A055 b;
};
struct A055_extra_alignment var238;
#pragma pack(1)
struct A055_extra_packed {
A055 a;
};
#pragma pack()
struct A055_extra_required_alignment {
char a;
struct A055_extra_packed b;
};
struct A055_extra_required_alignment var239;
struct A055_extra_size {
char a[sizeof(A055)+1];
char b;
};
struct A055_extra_size var240;
typedef enum {
F241 = 140737488355328,
} __attribute__((packed)) A056;
A056 var242;
struct A056_extra_alignment {
char a;
A056 b;
};
struct A056_extra_alignment var243;
#pragma pack(1)
struct A056_extra_packed {
A056 a;
};
#pragma pack()
struct A056_extra_required_alignment {
char a;
struct A056_extra_packed b;
};
struct A056_extra_required_alignment var244;
struct A056_extra_size {
char a[sizeof(A056)+1];
char b;
};
struct A056_extra_size var245;
typedef enum {
F246 = 281474976710656,
} __attribute__((packed)) A061;
A061 var247;
struct A061_extra_alignment {
char a;
A061 b;
};
struct A061_extra_alignment var248;
#pragma pack(1)
struct A061_extra_packed {
A061 a;
};
#pragma pack()
struct A061_extra_required_alignment {
char a;
struct A061_extra_packed b;
};
struct A061_extra_required_alignment var249;
struct A061_extra_size {
char a[sizeof(A061)+1];
char b;
};
struct A061_extra_size var250;
typedef enum {
F251 = 562949953421312,
} __attribute__((packed)) A062;
A062 var252;
struct A062_extra_alignment {
char a;
A062 b;
};
struct A062_extra_alignment var253;
#pragma pack(1)
struct A062_extra_packed {
A062 a;
};
#pragma pack()
struct A062_extra_required_alignment {
char a;
struct A062_extra_packed b;
};
struct A062_extra_required_alignment var254;
struct A062_extra_size {
char a[sizeof(A062)+1];
char b;
};
struct A062_extra_size var255;
typedef enum {
F256 = 1125899906842624,
} __attribute__((packed)) A063;
A063 var257;
struct A063_extra_alignment {
char a;
A063 b;
};
struct A063_extra_alignment var258;
#pragma pack(1)
struct A063_extra_packed {
A063 a;
};
#pragma pack()
struct A063_extra_required_alignment {
char a;
struct A063_extra_packed b;
};
struct A063_extra_required_alignment var259;
struct A063_extra_size {
char a[sizeof(A063)+1];
char b;
};
struct A063_extra_size var260;
typedef enum {
F261 = 2251799813685248,
} __attribute__((packed)) A064;
A064 var262;
struct A064_extra_alignment {
char a;
A064 b;
};
struct A064_extra_alignment var263;
#pragma pack(1)
struct A064_extra_packed {
A064 a;
};
#pragma pack()
struct A064_extra_required_alignment {
char a;
struct A064_extra_packed b;
};
struct A064_extra_required_alignment var264;
struct A064_extra_size {
char a[sizeof(A064)+1];
char b;
};
struct A064_extra_size var265;
typedef enum {
F266 = 4503599627370496,
} __attribute__((packed)) A065;
A065 var267;
struct A065_extra_alignment {
char a;
A065 b;
};
struct A065_extra_alignment var268;
#pragma pack(1)
struct A065_extra_packed {
A065 a;
};
#pragma pack()
struct A065_extra_required_alignment {
char a;
struct A065_extra_packed b;
};
struct A065_extra_required_alignment var269;
struct A065_extra_size {
char a[sizeof(A065)+1];
char b;
};
struct A065_extra_size var270;
typedef enum {
F271 = 9007199254740992,
} __attribute__((packed)) A066;
A066 var272;
struct A066_extra_alignment {
char a;
A066 b;
};
struct A066_extra_alignment var273;
#pragma pack(1)
struct A066_extra_packed {
A066 a;
};
#pragma pack()
struct A066_extra_required_alignment {
char a;
struct A066_extra_packed b;
};
struct A066_extra_required_alignment var274;
struct A066_extra_size {
char a[sizeof(A066)+1];
char b;
};
struct A066_extra_size var275;
typedef enum {
F276 = 18014398509481984,
} __attribute__((packed)) A067;
A067 var277;
struct A067_extra_alignment {
char a;
A067 b;
};
struct A067_extra_alignment var278;
#pragma pack(1)
struct A067_extra_packed {
A067 a;
};
#pragma pack()
struct A067_extra_required_alignment {
char a;
struct A067_extra_packed b;
};
struct A067_extra_required_alignment var279;
struct A067_extra_size {
char a[sizeof(A067)+1];
char b;
};
struct A067_extra_size var280;
typedef enum {
F281 = 36028797018963968,
} __attribute__((packed)) A068;
A068 var282;
struct A068_extra_alignment {
char a;
A068 b;
};
struct A068_extra_alignment var283;
#pragma pack(1)
struct A068_extra_packed {
A068 a;
};
#pragma pack()
struct A068_extra_required_alignment {
char a;
struct A068_extra_packed b;
};
struct A068_extra_required_alignment var284;
struct A068_extra_size {
char a[sizeof(A068)+1];
char b;
};
struct A068_extra_size var285;
typedef enum {
F286 = 72057594037927936,
} __attribute__((packed)) A069;
A069 var287;
struct A069_extra_alignment {
char a;
A069 b;
};
struct A069_extra_alignment var288;
#pragma pack(1)
struct A069_extra_packed {
A069 a;
};
#pragma pack()
struct A069_extra_required_alignment {
char a;
struct A069_extra_packed b;
};
struct A069_extra_required_alignment var289;
struct A069_extra_size {
char a[sizeof(A069)+1];
char b;
};
struct A069_extra_size var290;
typedef enum {
F291 = 144115188075855872,
} __attribute__((packed)) A070;
A070 var292;
struct A070_extra_alignment {
char a;
A070 b;
};
struct A070_extra_alignment var293;
#pragma pack(1)
struct A070_extra_packed {
A070 a;
};
#pragma pack()
struct A070_extra_required_alignment {
char a;
struct A070_extra_packed b;
};
struct A070_extra_required_alignment var294;
struct A070_extra_size {
char a[sizeof(A070)+1];
char b;
};
struct A070_extra_size var295;
typedef enum {
F296 = 288230376151711744,
} __attribute__((packed)) A071;
A071 var297;
struct A071_extra_alignment {
char a;
A071 b;
};
struct A071_extra_alignment var298;
#pragma pack(1)
struct A071_extra_packed {
A071 a;
};
#pragma pack()
struct A071_extra_required_alignment {
char a;
struct A071_extra_packed b;
};
struct A071_extra_required_alignment var299;
struct A071_extra_size {
char a[sizeof(A071)+1];
char b;
};
struct A071_extra_size var300;
typedef enum {
F301 = 576460752303423488,
} __attribute__((packed)) A072;
A072 var302;
struct A072_extra_alignment {
char a;
A072 b;
};
struct A072_extra_alignment var303;
#pragma pack(1)
struct A072_extra_packed {
A072 a;
};
#pragma pack()
struct A072_extra_required_alignment {
char a;
struct A072_extra_packed b;
};
struct A072_extra_required_alignment var304;
struct A072_extra_size {
char a[sizeof(A072)+1];
char b;
};
struct A072_extra_size var305;
typedef enum {
F306 = 1152921504606846976,
} __attribute__((packed)) A073;
A073 var307;
struct A073_extra_alignment {
char a;
A073 b;
};
struct A073_extra_alignment var308;
#pragma pack(1)
struct A073_extra_packed {
A073 a;
};
#pragma pack()
struct A073_extra_required_alignment {
char a;
struct A073_extra_packed b;
};
struct A073_extra_required_alignment var309;
struct A073_extra_size {
char a[sizeof(A073)+1];
char b;
};
struct A073_extra_size var310;
typedef enum {
F311 = 2305843009213693952,
} __attribute__((packed)) A074;
A074 var312;
struct A074_extra_alignment {
char a;
A074 b;
};
struct A074_extra_alignment var313;
#pragma pack(1)
struct A074_extra_packed {
A074 a;
};
#pragma pack()
struct A074_extra_required_alignment {
char a;
struct A074_extra_packed b;
};
struct A074_extra_required_alignment var314;
struct A074_extra_size {
char a[sizeof(A074)+1];
char b;
};
struct A074_extra_size var315;
typedef enum {
F316 = 4611686018427387904,
} __attribute__((packed)) A075;
A075 var317;
struct A075_extra_alignment {
char a;
A075 b;
};
struct A075_extra_alignment var318;
#pragma pack(1)
struct A075_extra_packed {
A075 a;
};
#pragma pack()
struct A075_extra_required_alignment {
char a;
struct A075_extra_packed b;
};
struct A075_extra_required_alignment var319;
struct A075_extra_size {
char a[sizeof(A075)+1];
char b;
};
struct A075_extra_size var320;
typedef enum {
F321 = 9223372036854775808ULL,
} __attribute__((packed)) A076;
A076 var322;
struct A076_extra_alignment {
char a;
A076 b;
};
struct A076_extra_alignment var323;
#pragma pack(1)
struct A076_extra_packed {
A076 a;
};
#pragma pack()
struct A076_extra_required_alignment {
char a;
struct A076_extra_packed b;
};
struct A076_extra_required_alignment var324;
struct A076_extra_size {
char a[sizeof(A076)+1];
char b;
};
struct A076_extra_size var325;
typedef enum {
F326 = -1,
} __attribute__((packed)) A081;
A081 var327;
struct A081_extra_alignment {
char a;
A081 b;
};
struct A081_extra_alignment var328;
#pragma pack(1)
struct A081_extra_packed {
A081 a;
};
#pragma pack()
struct A081_extra_required_alignment {
char a;
struct A081_extra_packed b;
};
struct A081_extra_required_alignment var329;
struct A081_extra_size {
char a[sizeof(A081)+1];
char b;
};
struct A081_extra_size var330;
typedef enum {
F331 = -2,
} __attribute__((packed)) A082;
A082 var332;
struct A082_extra_alignment {
char a;
A082 b;
};
struct A082_extra_alignment var333;
#pragma pack(1)
struct A082_extra_packed {
A082 a;
};
#pragma pack()
struct A082_extra_required_alignment {
char a;
struct A082_extra_packed b;
};
struct A082_extra_required_alignment var334;
struct A082_extra_size {
char a[sizeof(A082)+1];
char b;
};
struct A082_extra_size var335;
typedef enum {
F336 = -4,
} __attribute__((packed)) A083;
A083 var337;
struct A083_extra_alignment {
char a;
A083 b;
};
struct A083_extra_alignment var338;
#pragma pack(1)
struct A083_extra_packed {
A083 a;
};
#pragma pack()
struct A083_extra_required_alignment {
char a;
struct A083_extra_packed b;
};
struct A083_extra_required_alignment var339;
struct A083_extra_size {
char a[sizeof(A083)+1];
char b;
};
struct A083_extra_size var340;
typedef enum {
F341 = -8,
} __attribute__((packed)) A084;
A084 var342;
struct A084_extra_alignment {
char a;
A084 b;
};
struct A084_extra_alignment var343;
#pragma pack(1)
struct A084_extra_packed {
A084 a;
};
#pragma pack()
struct A084_extra_required_alignment {
char a;
struct A084_extra_packed b;
};
struct A084_extra_required_alignment var344;
struct A084_extra_size {
char a[sizeof(A084)+1];
char b;
};
struct A084_extra_size var345;
typedef enum {
F346 = -16,
} __attribute__((packed)) A085;
A085 var347;
struct A085_extra_alignment {
char a;
A085 b;
};
struct A085_extra_alignment var348;
#pragma pack(1)
struct A085_extra_packed {
A085 a;
};
#pragma pack()
struct A085_extra_required_alignment {
char a;
struct A085_extra_packed b;
};
struct A085_extra_required_alignment var349;
struct A085_extra_size {
char a[sizeof(A085)+1];
char b;
};
struct A085_extra_size var350;
typedef enum {
F351 = -32,
} __attribute__((packed)) A086;
A086 var352;
struct A086_extra_alignment {
char a;
A086 b;
};
struct A086_extra_alignment var353;
#pragma pack(1)
struct A086_extra_packed {
A086 a;
};
#pragma pack()
struct A086_extra_required_alignment {
char a;
struct A086_extra_packed b;
};
struct A086_extra_required_alignment var354;
struct A086_extra_size {
char a[sizeof(A086)+1];
char b;
};
struct A086_extra_size var355;
typedef enum {
F356 = -64,
} __attribute__((packed)) A087;
A087 var357;
struct A087_extra_alignment {
char a;
A087 b;
};
struct A087_extra_alignment var358;
#pragma pack(1)
struct A087_extra_packed {
A087 a;
};
#pragma pack()
struct A087_extra_required_alignment {
char a;
struct A087_extra_packed b;
};
struct A087_extra_required_alignment var359;
struct A087_extra_size {
char a[sizeof(A087)+1];
char b;
};
struct A087_extra_size var360;
typedef enum {
F361 = -128,
} __attribute__((packed)) A088;
A088 var362;
struct A088_extra_alignment {
char a;
A088 b;
};
struct A088_extra_alignment var363;
#pragma pack(1)
struct A088_extra_packed {
A088 a;
};
#pragma pack()
struct A088_extra_required_alignment {
char a;
struct A088_extra_packed b;
};
struct A088_extra_required_alignment var364;
struct A088_extra_size {
char a[sizeof(A088)+1];
char b;
};
struct A088_extra_size var365;
typedef enum {
F366 = -256,
} __attribute__((packed)) A089;
A089 var367;
struct A089_extra_alignment {
char a;
A089 b;
};
struct A089_extra_alignment var368;
#pragma pack(1)
struct A089_extra_packed {
A089 a;
};
#pragma pack()
struct A089_extra_required_alignment {
char a;
struct A089_extra_packed b;
};
struct A089_extra_required_alignment var369;
struct A089_extra_size {
char a[sizeof(A089)+1];
char b;
};
struct A089_extra_size var370;
typedef enum {
F371 = -512,
} __attribute__((packed)) A090;
A090 var372;
struct A090_extra_alignment {
char a;
A090 b;
};
struct A090_extra_alignment var373;
#pragma pack(1)
struct A090_extra_packed {
A090 a;
};
#pragma pack()
struct A090_extra_required_alignment {
char a;
struct A090_extra_packed b;
};
struct A090_extra_required_alignment var374;
struct A090_extra_size {
char a[sizeof(A090)+1];
char b;
};
struct A090_extra_size var375;
typedef enum {
F376 = -1024,
} __attribute__((packed)) A091;
A091 var377;
struct A091_extra_alignment {
char a;
A091 b;
};
struct A091_extra_alignment var378;
#pragma pack(1)
struct A091_extra_packed {
A091 a;
};
#pragma pack()
struct A091_extra_required_alignment {
char a;
struct A091_extra_packed b;
};
struct A091_extra_required_alignment var379;
struct A091_extra_size {
char a[sizeof(A091)+1];
char b;
};
struct A091_extra_size var380;
typedef enum {
F381 = -2048,
} __attribute__((packed)) A092;
A092 var382;
struct A092_extra_alignment {
char a;
A092 b;
};
struct A092_extra_alignment var383;
#pragma pack(1)
struct A092_extra_packed {
A092 a;
};
#pragma pack()
struct A092_extra_required_alignment {
char a;
struct A092_extra_packed b;
};
struct A092_extra_required_alignment var384;
struct A092_extra_size {
char a[sizeof(A092)+1];
char b;
};
struct A092_extra_size var385;
typedef enum {
F386 = -4096,
} __attribute__((packed)) A093;
A093 var387;
struct A093_extra_alignment {
char a;
A093 b;
};
struct A093_extra_alignment var388;
#pragma pack(1)
struct A093_extra_packed {
A093 a;
};
#pragma pack()
struct A093_extra_required_alignment {
char a;
struct A093_extra_packed b;
};
struct A093_extra_required_alignment var389;
struct A093_extra_size {
char a[sizeof(A093)+1];
char b;
};
struct A093_extra_size var390;
typedef enum {
F391 = -8192,
} __attribute__((packed)) A094;
A094 var392;
struct A094_extra_alignment {
char a;
A094 b;
};
struct A094_extra_alignment var393;
#pragma pack(1)
struct A094_extra_packed {
A094 a;
};
#pragma pack()
struct A094_extra_required_alignment {
char a;
struct A094_extra_packed b;
};
struct A094_extra_required_alignment var394;
struct A094_extra_size {
char a[sizeof(A094)+1];
char b;
};
struct A094_extra_size var395;
typedef enum {
F396 = -16384,
} __attribute__((packed)) A095;
A095 var397;
struct A095_extra_alignment {
char a;
A095 b;
};
struct A095_extra_alignment var398;
#pragma pack(1)
struct A095_extra_packed {
A095 a;
};
#pragma pack()
struct A095_extra_required_alignment {
char a;
struct A095_extra_packed b;
};
struct A095_extra_required_alignment var399;
struct A095_extra_size {
char a[sizeof(A095)+1];
char b;
};
struct A095_extra_size var400;
typedef enum {
F401 = -32768,
} __attribute__((packed)) A096;
A096 var402;
struct A096_extra_alignment {
char a;
A096 b;
};
struct A096_extra_alignment var403;
#pragma pack(1)
struct A096_extra_packed {
A096 a;
};
#pragma pack()
struct A096_extra_required_alignment {
char a;
struct A096_extra_packed b;
};
struct A096_extra_required_alignment var404;
struct A096_extra_size {
char a[sizeof(A096)+1];
char b;
};
struct A096_extra_size var405;
typedef enum {
F406 = -65536,
} __attribute__((packed)) A101;
A101 var407;
struct A101_extra_alignment {
char a;
A101 b;
};
struct A101_extra_alignment var408;
#pragma pack(1)
struct A101_extra_packed {
A101 a;
};
#pragma pack()
struct A101_extra_required_alignment {
char a;
struct A101_extra_packed b;
};
struct A101_extra_required_alignment var409;
struct A101_extra_size {
char a[sizeof(A101)+1];
char b;
};
struct A101_extra_size var410;
typedef enum {
F411 = -131072,
} __attribute__((packed)) A102;
A102 var412;
struct A102_extra_alignment {
char a;
A102 b;
};
struct A102_extra_alignment var413;
#pragma pack(1)
struct A102_extra_packed {
A102 a;
};
#pragma pack()
struct A102_extra_required_alignment {
char a;
struct A102_extra_packed b;
};
struct A102_extra_required_alignment var414;
struct A102_extra_size {
char a[sizeof(A102)+1];
char b;
};
struct A102_extra_size var415;
typedef enum {
F416 = -262144,
} __attribute__((packed)) A103;
A103 var417;
struct A103_extra_alignment {
char a;
A103 b;
};
struct A103_extra_alignment var418;
#pragma pack(1)
struct A103_extra_packed {
A103 a;
};
#pragma pack()
struct A103_extra_required_alignment {
char a;
struct A103_extra_packed b;
};
struct A103_extra_required_alignment var419;
struct A103_extra_size {
char a[sizeof(A103)+1];
char b;
};
struct A103_extra_size var420;
typedef enum {
F421 = -524288,
} __attribute__((packed)) A104;
A104 var422;
struct A104_extra_alignment {
char a;
A104 b;
};
struct A104_extra_alignment var423;
#pragma pack(1)
struct A104_extra_packed {
A104 a;
};
#pragma pack()
struct A104_extra_required_alignment {
char a;
struct A104_extra_packed b;
};
struct A104_extra_required_alignment var424;
struct A104_extra_size {
char a[sizeof(A104)+1];
char b;
};
struct A104_extra_size var425;
typedef enum {
F426 = -1048576,
} __attribute__((packed)) A105;
A105 var427;
struct A105_extra_alignment {
char a;
A105 b;
};
struct A105_extra_alignment var428;
#pragma pack(1)
struct A105_extra_packed {
A105 a;
};
#pragma pack()
struct A105_extra_required_alignment {
char a;
struct A105_extra_packed b;
};
struct A105_extra_required_alignment var429;
struct A105_extra_size {
char a[sizeof(A105)+1];
char b;
};
struct A105_extra_size var430;
typedef enum {
F431 = -2097152,
} __attribute__((packed)) A106;
A106 var432;
struct A106_extra_alignment {
char a;
A106 b;
};
struct A106_extra_alignment var433;
#pragma pack(1)
struct A106_extra_packed {
A106 a;
};
#pragma pack()
struct A106_extra_required_alignment {
char a;
struct A106_extra_packed b;
};
struct A106_extra_required_alignment var434;
struct A106_extra_size {
char a[sizeof(A106)+1];
char b;
};
struct A106_extra_size var435;
typedef enum {
F436 = -4194304,
} __attribute__((packed)) A107;
A107 var437;
struct A107_extra_alignment {
char a;
A107 b;
};
struct A107_extra_alignment var438;
#pragma pack(1)
struct A107_extra_packed {
A107 a;
};
#pragma pack()
struct A107_extra_required_alignment {
char a;
struct A107_extra_packed b;
};
struct A107_extra_required_alignment var439;
struct A107_extra_size {
char a[sizeof(A107)+1];
char b;
};
struct A107_extra_size var440;
typedef enum {
F441 = -8388608,
} __attribute__((packed)) A108;
A108 var442;
struct A108_extra_alignment {
char a;
A108 b;
};
struct A108_extra_alignment var443;
#pragma pack(1)
struct A108_extra_packed {
A108 a;
};
#pragma pack()
struct A108_extra_required_alignment {
char a;
struct A108_extra_packed b;
};
struct A108_extra_required_alignment var444;
struct A108_extra_size {
char a[sizeof(A108)+1];
char b;
};
struct A108_extra_size var445;
typedef enum {
F446 = -16777216,
} __attribute__((packed)) A109;
A109 var447;
struct A109_extra_alignment {
char a;
A109 b;
};
struct A109_extra_alignment var448;
#pragma pack(1)
struct A109_extra_packed {
A109 a;
};
#pragma pack()
struct A109_extra_required_alignment {
char a;
struct A109_extra_packed b;
};
struct A109_extra_required_alignment var449;
struct A109_extra_size {
char a[sizeof(A109)+1];
char b;
};
struct A109_extra_size var450;
typedef enum {
F451 = -33554432,
} __attribute__((packed)) A110;
A110 var452;
struct A110_extra_alignment {
char a;
A110 b;
};
struct A110_extra_alignment var453;
#pragma pack(1)
struct A110_extra_packed {
A110 a;
};
#pragma pack()
struct A110_extra_required_alignment {
char a;
struct A110_extra_packed b;
};
struct A110_extra_required_alignment var454;
struct A110_extra_size {
char a[sizeof(A110)+1];
char b;
};
struct A110_extra_size var455;
typedef enum {
F456 = -67108864,
} __attribute__((packed)) A111;
A111 var457;
struct A111_extra_alignment {
char a;
A111 b;
};
struct A111_extra_alignment var458;
#pragma pack(1)
struct A111_extra_packed {
A111 a;
};
#pragma pack()
struct A111_extra_required_alignment {
char a;
struct A111_extra_packed b;
};
struct A111_extra_required_alignment var459;
struct A111_extra_size {
char a[sizeof(A111)+1];
char b;
};
struct A111_extra_size var460;
typedef enum {
F461 = -134217728,
} __attribute__((packed)) A112;
A112 var462;
struct A112_extra_alignment {
char a;
A112 b;
};
struct A112_extra_alignment var463;
#pragma pack(1)
struct A112_extra_packed {
A112 a;
};
#pragma pack()
struct A112_extra_required_alignment {
char a;
struct A112_extra_packed b;
};
struct A112_extra_required_alignment var464;
struct A112_extra_size {
char a[sizeof(A112)+1];
char b;
};
struct A112_extra_size var465;
typedef enum {
F466 = -268435456,
} __attribute__((packed)) A113;
A113 var467;
struct A113_extra_alignment {
char a;
A113 b;
};
struct A113_extra_alignment var468;
#pragma pack(1)
struct A113_extra_packed {
A113 a;
};
#pragma pack()
struct A113_extra_required_alignment {
char a;
struct A113_extra_packed b;
};
struct A113_extra_required_alignment var469;
struct A113_extra_size {
char a[sizeof(A113)+1];
char b;
};
struct A113_extra_size var470;
typedef enum {
F471 = -536870912,
} __attribute__((packed)) A114;
A114 var472;
struct A114_extra_alignment {
char a;
A114 b;
};
struct A114_extra_alignment var473;
#pragma pack(1)
struct A114_extra_packed {
A114 a;
};
#pragma pack()
struct A114_extra_required_alignment {
char a;
struct A114_extra_packed b;
};
struct A114_extra_required_alignment var474;
struct A114_extra_size {
char a[sizeof(A114)+1];
char b;
};
struct A114_extra_size var475;
typedef enum {
F476 = -1073741824,
} __attribute__((packed)) A115;
A115 var477;
struct A115_extra_alignment {
char a;
A115 b;
};
struct A115_extra_alignment var478;
#pragma pack(1)
struct A115_extra_packed {
A115 a;
};
#pragma pack()
struct A115_extra_required_alignment {
char a;
struct A115_extra_packed b;
};
struct A115_extra_required_alignment var479;
struct A115_extra_size {
char a[sizeof(A115)+1];
char b;
};
struct A115_extra_size var480;
typedef enum {
F481 = -2147483648,
} __attribute__((packed)) A116;
A116 var482;
struct A116_extra_alignment {
char a;
A116 b;
};
struct A116_extra_alignment var483;
#pragma pack(1)
struct A116_extra_packed {
A116 a;
};
#pragma pack()
struct A116_extra_required_alignment {
char a;
struct A116_extra_packed b;
};
struct A116_extra_required_alignment var484;
struct A116_extra_size {
char a[sizeof(A116)+1];
char b;
};
struct A116_extra_size var485;
typedef enum {
F486 = -4294967296,
} __attribute__((packed)) A121;
A121 var487;
struct A121_extra_alignment {
char a;
A121 b;
};
struct A121_extra_alignment var488;
#pragma pack(1)
struct A121_extra_packed {
A121 a;
};
#pragma pack()
struct A121_extra_required_alignment {
char a;
struct A121_extra_packed b;
};
struct A121_extra_required_alignment var489;
struct A121_extra_size {
char a[sizeof(A121)+1];
char b;
};
struct A121_extra_size var490;
typedef enum {
F491 = -8589934592,
} __attribute__((packed)) A122;
A122 var492;
struct A122_extra_alignment {
char a;
A122 b;
};
struct A122_extra_alignment var493;
#pragma pack(1)
struct A122_extra_packed {
A122 a;
};
#pragma pack()
struct A122_extra_required_alignment {
char a;
struct A122_extra_packed b;
};
struct A122_extra_required_alignment var494;
struct A122_extra_size {
char a[sizeof(A122)+1];
char b;
};
struct A122_extra_size var495;
typedef enum {
F496 = -17179869184,
} __attribute__((packed)) A123;
A123 var497;
struct A123_extra_alignment {
char a;
A123 b;
};
struct A123_extra_alignment var498;
#pragma pack(1)
struct A123_extra_packed {
A123 a;
};
#pragma pack()
struct A123_extra_required_alignment {
char a;
struct A123_extra_packed b;
};
struct A123_extra_required_alignment var499;
struct A123_extra_size {
char a[sizeof(A123)+1];
char b;
};
struct A123_extra_size var500;
typedef enum {
F501 = -34359738368,
} __attribute__((packed)) A124;
A124 var502;
struct A124_extra_alignment {
char a;
A124 b;
};
struct A124_extra_alignment var503;
#pragma pack(1)
struct A124_extra_packed {
A124 a;
};
#pragma pack()
struct A124_extra_required_alignment {
char a;
struct A124_extra_packed b;
};
struct A124_extra_required_alignment var504;
struct A124_extra_size {
char a[sizeof(A124)+1];
char b;
};
struct A124_extra_size var505;
typedef enum {
F506 = -68719476736,
} __attribute__((packed)) A125;
A125 var507;
struct A125_extra_alignment {
char a;
A125 b;
};
struct A125_extra_alignment var508;
#pragma pack(1)
struct A125_extra_packed {
A125 a;
};
#pragma pack()
struct A125_extra_required_alignment {
char a;
struct A125_extra_packed b;
};
struct A125_extra_required_alignment var509;
struct A125_extra_size {
char a[sizeof(A125)+1];
char b;
};
struct A125_extra_size var510;
typedef enum {
F511 = -137438953472,
} __attribute__((packed)) A126;
A126 var512;
struct A126_extra_alignment {
char a;
A126 b;
};
struct A126_extra_alignment var513;
#pragma pack(1)
struct A126_extra_packed {
A126 a;
};
#pragma pack()
struct A126_extra_required_alignment {
char a;
struct A126_extra_packed b;
};
struct A126_extra_required_alignment var514;
struct A126_extra_size {
char a[sizeof(A126)+1];
char b;
};
struct A126_extra_size var515;
typedef enum {
F516 = -274877906944,
} __attribute__((packed)) A127;
A127 var517;
struct A127_extra_alignment {
char a;
A127 b;
};
struct A127_extra_alignment var518;
#pragma pack(1)
struct A127_extra_packed {
A127 a;
};
#pragma pack()
struct A127_extra_required_alignment {
char a;
struct A127_extra_packed b;
};
struct A127_extra_required_alignment var519;
struct A127_extra_size {
char a[sizeof(A127)+1];
char b;
};
struct A127_extra_size var520;
typedef enum {
F521 = -549755813888,
} __attribute__((packed)) A128;
A128 var522;
struct A128_extra_alignment {
char a;
A128 b;
};
struct A128_extra_alignment var523;
#pragma pack(1)
struct A128_extra_packed {
A128 a;
};
#pragma pack()
struct A128_extra_required_alignment {
char a;
struct A128_extra_packed b;
};
struct A128_extra_required_alignment var524;
struct A128_extra_size {
char a[sizeof(A128)+1];
char b;
};
struct A128_extra_size var525;
typedef enum {
F526 = -1099511627776,
} __attribute__((packed)) A129;
A129 var527;
struct A129_extra_alignment {
char a;
A129 b;
};
struct A129_extra_alignment var528;
#pragma pack(1)
struct A129_extra_packed {
A129 a;
};
#pragma pack()
struct A129_extra_required_alignment {
char a;
struct A129_extra_packed b;
};
struct A129_extra_required_alignment var529;
struct A129_extra_size {
char a[sizeof(A129)+1];
char b;
};
struct A129_extra_size var530;
typedef enum {
F531 = -2199023255552,
} __attribute__((packed)) A130;
A130 var532;
struct A130_extra_alignment {
char a;
A130 b;
};
struct A130_extra_alignment var533;
#pragma pack(1)
struct A130_extra_packed {
A130 a;
};
#pragma pack()
struct A130_extra_required_alignment {
char a;
struct A130_extra_packed b;
};
struct A130_extra_required_alignment var534;
struct A130_extra_size {
char a[sizeof(A130)+1];
char b;
};
struct A130_extra_size var535;
typedef enum {
F536 = -4398046511104,
} __attribute__((packed)) A131;
A131 var537;
struct A131_extra_alignment {
char a;
A131 b;
};
struct A131_extra_alignment var538;
#pragma pack(1)
struct A131_extra_packed {
A131 a;
};
#pragma pack()
struct A131_extra_required_alignment {
char a;
struct A131_extra_packed b;
};
struct A131_extra_required_alignment var539;
struct A131_extra_size {
char a[sizeof(A131)+1];
char b;
};
struct A131_extra_size var540;
typedef enum {
F541 = -8796093022208,
} __attribute__((packed)) A132;
A132 var542;
struct A132_extra_alignment {
char a;
A132 b;
};
struct A132_extra_alignment var543;
#pragma pack(1)
struct A132_extra_packed {
A132 a;
};
#pragma pack()
struct A132_extra_required_alignment {
char a;
struct A132_extra_packed b;
};
struct A132_extra_required_alignment var544;
struct A132_extra_size {
char a[sizeof(A132)+1];
char b;
};
struct A132_extra_size var545;
typedef enum {
F546 = -17592186044416,
} __attribute__((packed)) A133;
A133 var547;
struct A133_extra_alignment {
char a;
A133 b;
};
struct A133_extra_alignment var548;
#pragma pack(1)
struct A133_extra_packed {
A133 a;
};
#pragma pack()
struct A133_extra_required_alignment {
char a;
struct A133_extra_packed b;
};
struct A133_extra_required_alignment var549;
struct A133_extra_size {
char a[sizeof(A133)+1];
char b;
};
struct A133_extra_size var550;
typedef enum {
F551 = -35184372088832,
} __attribute__((packed)) A134;
A134 var552;
struct A134_extra_alignment {
char a;
A134 b;
};
struct A134_extra_alignment var553;
#pragma pack(1)
struct A134_extra_packed {
A134 a;
};
#pragma pack()
struct A134_extra_required_alignment {
char a;
struct A134_extra_packed b;
};
struct A134_extra_required_alignment var554;
struct A134_extra_size {
char a[sizeof(A134)+1];
char b;
};
struct A134_extra_size var555;
typedef enum {
F556 = -70368744177664,
} __attribute__((packed)) A135;
A135 var557;
struct A135_extra_alignment {
char a;
A135 b;
};
struct A135_extra_alignment var558;
#pragma pack(1)
struct A135_extra_packed {
A135 a;
};
#pragma pack()
struct A135_extra_required_alignment {
char a;
struct A135_extra_packed b;
};
struct A135_extra_required_alignment var559;
struct A135_extra_size {
char a[sizeof(A135)+1];
char b;
};
struct A135_extra_size var560;
typedef enum {
F561 = -140737488355328,
} __attribute__((packed)) A136;
A136 var562;
struct A136_extra_alignment {
char a;
A136 b;
};
struct A136_extra_alignment var563;
#pragma pack(1)
struct A136_extra_packed {
A136 a;
};
#pragma pack()
struct A136_extra_required_alignment {
char a;
struct A136_extra_packed b;
};
struct A136_extra_required_alignment var564;
struct A136_extra_size {
char a[sizeof(A136)+1];
char b;
};
struct A136_extra_size var565;
typedef enum {
F566 = -281474976710656,
} __attribute__((packed)) A141;
A141 var567;
struct A141_extra_alignment {
char a;
A141 b;
};
struct A141_extra_alignment var568;
#pragma pack(1)
struct A141_extra_packed {
A141 a;
};
#pragma pack()
struct A141_extra_required_alignment {
char a;
struct A141_extra_packed b;
};
struct A141_extra_required_alignment var569;
struct A141_extra_size {
char a[sizeof(A141)+1];
char b;
};
struct A141_extra_size var570;
typedef enum {
F571 = -562949953421312,
} __attribute__((packed)) A142;
A142 var572;
struct A142_extra_alignment {
char a;
A142 b;
};
struct A142_extra_alignment var573;
#pragma pack(1)
struct A142_extra_packed {
A142 a;
};
#pragma pack()
struct A142_extra_required_alignment {
char a;
struct A142_extra_packed b;
};
struct A142_extra_required_alignment var574;
struct A142_extra_size {
char a[sizeof(A142)+1];
char b;
};
struct A142_extra_size var575;
typedef enum {
F576 = -1125899906842624,
} __attribute__((packed)) A143;
A143 var577;
struct A143_extra_alignment {
char a;
A143 b;
};
struct A143_extra_alignment var578;
#pragma pack(1)
struct A143_extra_packed {
A143 a;
};
#pragma pack()
struct A143_extra_required_alignment {
char a;
struct A143_extra_packed b;
};
struct A143_extra_required_alignment var579;
struct A143_extra_size {
char a[sizeof(A143)+1];
char b;
};
struct A143_extra_size var580;
typedef enum {
F581 = -2251799813685248,
} __attribute__((packed)) A144;
A144 var582;
struct A144_extra_alignment {
char a;
A144 b;
};
struct A144_extra_alignment var583;
#pragma pack(1)
struct A144_extra_packed {
A144 a;
};
#pragma pack()
struct A144_extra_required_alignment {
char a;
struct A144_extra_packed b;
};
struct A144_extra_required_alignment var584;
struct A144_extra_size {
char a[sizeof(A144)+1];
char b;
};
struct A144_extra_size var585;
typedef enum {
F586 = -4503599627370496,
} __attribute__((packed)) A145;
A145 var587;
struct A145_extra_alignment {
char a;
A145 b;
};
struct A145_extra_alignment var588;
#pragma pack(1)
struct A145_extra_packed {
A145 a;
};
#pragma pack()
struct A145_extra_required_alignment {
char a;
struct A145_extra_packed b;
};
struct A145_extra_required_alignment var589;
struct A145_extra_size {
char a[sizeof(A145)+1];
char b;
};
struct A145_extra_size var590;
typedef enum {
F591 = -9007199254740992,
} __attribute__((packed)) A146;
A146 var592;
struct A146_extra_alignment {
char a;
A146 b;
};
struct A146_extra_alignment var593;
#pragma pack(1)
struct A146_extra_packed {
A146 a;
};
#pragma pack()
struct A146_extra_required_alignment {
char a;
struct A146_extra_packed b;
};
struct A146_extra_required_alignment var594;
struct A146_extra_size {
char a[sizeof(A146)+1];
char b;
};
struct A146_extra_size var595;
typedef enum {
F596 = -18014398509481984,
} __attribute__((packed)) A147;
A147 var597;
struct A147_extra_alignment {
char a;
A147 b;
};
struct A147_extra_alignment var598;
#pragma pack(1)
struct A147_extra_packed {
A147 a;
};
#pragma pack()
struct A147_extra_required_alignment {
char a;
struct A147_extra_packed b;
};
struct A147_extra_required_alignment var599;
struct A147_extra_size {
char a[sizeof(A147)+1];
char b;
};
struct A147_extra_size var600;
typedef enum {
F601 = -36028797018963968,
} __attribute__((packed)) A148;
A148 var602;
struct A148_extra_alignment {
char a;
A148 b;
};
struct A148_extra_alignment var603;
#pragma pack(1)
struct A148_extra_packed {
A148 a;
};
#pragma pack()
struct A148_extra_required_alignment {
char a;
struct A148_extra_packed b;
};
struct A148_extra_required_alignment var604;
struct A148_extra_size {
char a[sizeof(A148)+1];
char b;
};
struct A148_extra_size var605;
typedef enum {
F606 = -72057594037927936,
} __attribute__((packed)) A149;
A149 var607;
struct A149_extra_alignment {
char a;
A149 b;
};
struct A149_extra_alignment var608;
#pragma pack(1)
struct A149_extra_packed {
A149 a;
};
#pragma pack()
struct A149_extra_required_alignment {
char a;
struct A149_extra_packed b;
};
struct A149_extra_required_alignment var609;
struct A149_extra_size {
char a[sizeof(A149)+1];
char b;
};
struct A149_extra_size var610;
typedef enum {
F611 = -144115188075855872,
} __attribute__((packed)) A150;
A150 var612;
struct A150_extra_alignment {
char a;
A150 b;
};
struct A150_extra_alignment var613;
#pragma pack(1)
struct A150_extra_packed {
A150 a;
};
#pragma pack()
struct A150_extra_required_alignment {
char a;
struct A150_extra_packed b;
};
struct A150_extra_required_alignment var614;
struct A150_extra_size {
char a[sizeof(A150)+1];
char b;
};
struct A150_extra_size var615;
typedef enum {
F616 = -288230376151711744,
} __attribute__((packed)) A151;
A151 var617;
struct A151_extra_alignment {
char a;
A151 b;
};
struct A151_extra_alignment var618;
#pragma pack(1)
struct A151_extra_packed {
A151 a;
};
#pragma pack()
struct A151_extra_required_alignment {
char a;
struct A151_extra_packed b;
};
struct A151_extra_required_alignment var619;
struct A151_extra_size {
char a[sizeof(A151)+1];
char b;
};
struct A151_extra_size var620;
typedef enum {
F621 = -576460752303423488,
} __attribute__((packed)) A152;
A152 var622;
struct A152_extra_alignment {
char a;
A152 b;
};
struct A152_extra_alignment var623;
#pragma pack(1)
struct A152_extra_packed {
A152 a;
};
#pragma pack()
struct A152_extra_required_alignment {
char a;
struct A152_extra_packed b;
};
struct A152_extra_required_alignment var624;
struct A152_extra_size {
char a[sizeof(A152)+1];
char b;
};
struct A152_extra_size var625;
typedef enum {
F626 = -1152921504606846976,
} __attribute__((packed)) A153;
A153 var627;
struct A153_extra_alignment {
char a;
A153 b;
};
struct A153_extra_alignment var628;
#pragma pack(1)
struct A153_extra_packed {
A153 a;
};
#pragma pack()
struct A153_extra_required_alignment {
char a;
struct A153_extra_packed b;
};
struct A153_extra_required_alignment var629;
struct A153_extra_size {
char a[sizeof(A153)+1];
char b;
};
struct A153_extra_size var630;
typedef enum {
F631 = -2305843009213693952,
} __attribute__((packed)) A154;
A154 var632;
struct A154_extra_alignment {
char a;
A154 b;
};
struct A154_extra_alignment var633;
#pragma pack(1)
struct A154_extra_packed {
A154 a;
};
#pragma pack()
struct A154_extra_required_alignment {
char a;
struct A154_extra_packed b;
};
struct A154_extra_required_alignment var634;
struct A154_extra_size {
char a[sizeof(A154)+1];
char b;
};
struct A154_extra_size var635;
typedef enum {
F636 = -4611686018427387904,
} __attribute__((packed)) A155;
A155 var637;
struct A155_extra_alignment {
char a;
A155 b;
};
struct A155_extra_alignment var638;
#pragma pack(1)
struct A155_extra_packed {
A155 a;
};
#pragma pack()
struct A155_extra_required_alignment {
char a;
struct A155_extra_packed b;
};
struct A155_extra_required_alignment var639;
struct A155_extra_size {
char a[sizeof(A155)+1];
char b;
};
struct A155_extra_size var640;
typedef enum {
F641 = -9223372036854775808ULL,
} __attribute__((packed)) A156;
A156 var642;
struct A156_extra_alignment {
char a;
A156 b;
};
struct A156_extra_alignment var643;
#pragma pack(1)
struct A156_extra_packed {
A156 a;
};
#pragma pack()
struct A156_extra_required_alignment {
char a;
struct A156_extra_packed b;
};
struct A156_extra_required_alignment var644;
struct A156_extra_size {
char a[sizeof(A156)+1];
char b;
};
struct A156_extra_size var645;
typedef enum {
F646 = 0,
} B000;
B000 var647;
struct B000_extra_alignment {
char a;
B000 b;
};
struct B000_extra_alignment var648;
#pragma pack(1)
struct B000_extra_packed {
B000 a;
};
#pragma pack()
struct B000_extra_required_alignment {
char a;
struct B000_extra_packed b;
};
struct B000_extra_required_alignment var649;
struct B000_extra_size {
char a[sizeof(B000)+1];
char b;
};
struct B000_extra_size var650;
typedef enum {
F651 = 1,
} B001;
B001 var652;
struct B001_extra_alignment {
char a;
B001 b;
};
struct B001_extra_alignment var653;
#pragma pack(1)
struct B001_extra_packed {
B001 a;
};
#pragma pack()
struct B001_extra_required_alignment {
char a;
struct B001_extra_packed b;
};
struct B001_extra_required_alignment var654;
struct B001_extra_size {
char a[sizeof(B001)+1];
char b;
};
struct B001_extra_size var655;
typedef enum {
F656 = 2,
} B002;
B002 var657;
struct B002_extra_alignment {
char a;
B002 b;
};
struct B002_extra_alignment var658;
#pragma pack(1)
struct B002_extra_packed {
B002 a;
};
#pragma pack()
struct B002_extra_required_alignment {
char a;
struct B002_extra_packed b;
};
struct B002_extra_required_alignment var659;
struct B002_extra_size {
char a[sizeof(B002)+1];
char b;
};
struct B002_extra_size var660;
typedef enum {
F661 = 4,
} B003;
B003 var662;
struct B003_extra_alignment {
char a;
B003 b;
};
struct B003_extra_alignment var663;
#pragma pack(1)
struct B003_extra_packed {
B003 a;
};
#pragma pack()
struct B003_extra_required_alignment {
char a;
struct B003_extra_packed b;
};
struct B003_extra_required_alignment var664;
struct B003_extra_size {
char a[sizeof(B003)+1];
char b;
};
struct B003_extra_size var665;
typedef enum {
F666 = 8,
} B004;
B004 var667;
struct B004_extra_alignment {
char a;
B004 b;
};
struct B004_extra_alignment var668;
#pragma pack(1)
struct B004_extra_packed {
B004 a;
};
#pragma pack()
struct B004_extra_required_alignment {
char a;
struct B004_extra_packed b;
};
struct B004_extra_required_alignment var669;
struct B004_extra_size {
char a[sizeof(B004)+1];
char b;
};
struct B004_extra_size var670;
typedef enum {
F671 = 16,
} B005;
B005 var672;
struct B005_extra_alignment {
char a;
B005 b;
};
struct B005_extra_alignment var673;
#pragma pack(1)
struct B005_extra_packed {
B005 a;
};
#pragma pack()
struct B005_extra_required_alignment {
char a;
struct B005_extra_packed b;
};
struct B005_extra_required_alignment var674;
struct B005_extra_size {
char a[sizeof(B005)+1];
char b;
};
struct B005_extra_size var675;
typedef enum {
F676 = 32,
} B006;
B006 var677;
struct B006_extra_alignment {
char a;
B006 b;
};
struct B006_extra_alignment var678;
#pragma pack(1)
struct B006_extra_packed {
B006 a;
};
#pragma pack()
struct B006_extra_required_alignment {
char a;
struct B006_extra_packed b;
};
struct B006_extra_required_alignment var679;
struct B006_extra_size {
char a[sizeof(B006)+1];
char b;
};
struct B006_extra_size var680;
typedef enum {
F681 = 64,
} B007;
B007 var682;
struct B007_extra_alignment {
char a;
B007 b;
};
struct B007_extra_alignment var683;
#pragma pack(1)
struct B007_extra_packed {
B007 a;
};
#pragma pack()
struct B007_extra_required_alignment {
char a;
struct B007_extra_packed b;
};
struct B007_extra_required_alignment var684;
struct B007_extra_size {
char a[sizeof(B007)+1];
char b;
};
struct B007_extra_size var685;
typedef enum {
F686 = 128,
} B008;
B008 var687;
struct B008_extra_alignment {
char a;
B008 b;
};
struct B008_extra_alignment var688;
#pragma pack(1)
struct B008_extra_packed {
B008 a;
};
#pragma pack()
struct B008_extra_required_alignment {
char a;
struct B008_extra_packed b;
};
struct B008_extra_required_alignment var689;
struct B008_extra_size {
char a[sizeof(B008)+1];
char b;
};
struct B008_extra_size var690;
typedef enum {
F691 = 256,
} B009;
B009 var692;
struct B009_extra_alignment {
char a;
B009 b;
};
struct B009_extra_alignment var693;
#pragma pack(1)
struct B009_extra_packed {
B009 a;
};
#pragma pack()
struct B009_extra_required_alignment {
char a;
struct B009_extra_packed b;
};
struct B009_extra_required_alignment var694;
struct B009_extra_size {
char a[sizeof(B009)+1];
char b;
};
struct B009_extra_size var695;
typedef enum {
F696 = 512,
} B010;
B010 var697;
struct B010_extra_alignment {
char a;
B010 b;
};
struct B010_extra_alignment var698;
#pragma pack(1)
struct B010_extra_packed {
B010 a;
};
#pragma pack()
struct B010_extra_required_alignment {
char a;
struct B010_extra_packed b;
};
struct B010_extra_required_alignment var699;
struct B010_extra_size {
char a[sizeof(B010)+1];
char b;
};
struct B010_extra_size var700;
typedef enum {
F701 = 1024,
} B011;
B011 var702;
struct B011_extra_alignment {
char a;
B011 b;
};
struct B011_extra_alignment var703;
#pragma pack(1)
struct B011_extra_packed {
B011 a;
};
#pragma pack()
struct B011_extra_required_alignment {
char a;
struct B011_extra_packed b;
};
struct B011_extra_required_alignment var704;
struct B011_extra_size {
char a[sizeof(B011)+1];
char b;
};
struct B011_extra_size var705;
typedef enum {
F706 = 2048,
} B012;
B012 var707;
struct B012_extra_alignment {
char a;
B012 b;
};
struct B012_extra_alignment var708;
#pragma pack(1)
struct B012_extra_packed {
B012 a;
};
#pragma pack()
struct B012_extra_required_alignment {
char a;
struct B012_extra_packed b;
};
struct B012_extra_required_alignment var709;
struct B012_extra_size {
char a[sizeof(B012)+1];
char b;
};
struct B012_extra_size var710;
typedef enum {
F711 = 4096,
} B013;
B013 var712;
struct B013_extra_alignment {
char a;
B013 b;
};
struct B013_extra_alignment var713;
#pragma pack(1)
struct B013_extra_packed {
B013 a;
};
#pragma pack()
struct B013_extra_required_alignment {
char a;
struct B013_extra_packed b;
};
struct B013_extra_required_alignment var714;
struct B013_extra_size {
char a[sizeof(B013)+1];
char b;
};
struct B013_extra_size var715;
typedef enum {
F716 = 8192,
} B014;
B014 var717;
struct B014_extra_alignment {
char a;
B014 b;
};
struct B014_extra_alignment var718;
#pragma pack(1)
struct B014_extra_packed {
B014 a;
};
#pragma pack()
struct B014_extra_required_alignment {
char a;
struct B014_extra_packed b;
};
struct B014_extra_required_alignment var719;
struct B014_extra_size {
char a[sizeof(B014)+1];
char b;
};
struct B014_extra_size var720;
typedef enum {
F721 = 16384,
} B015;
B015 var722;
struct B015_extra_alignment {
char a;
B015 b;
};
struct B015_extra_alignment var723;
#pragma pack(1)
struct B015_extra_packed {
B015 a;
};
#pragma pack()
struct B015_extra_required_alignment {
char a;
struct B015_extra_packed b;
};
struct B015_extra_required_alignment var724;
struct B015_extra_size {
char a[sizeof(B015)+1];
char b;
};
struct B015_extra_size var725;
typedef enum {
F726 = 32768,
} B016;
B016 var727;
struct B016_extra_alignment {
char a;
B016 b;
};
struct B016_extra_alignment var728;
#pragma pack(1)
struct B016_extra_packed {
B016 a;
};
#pragma pack()
struct B016_extra_required_alignment {
char a;
struct B016_extra_packed b;
};
struct B016_extra_required_alignment var729;
struct B016_extra_size {
char a[sizeof(B016)+1];
char b;
};
struct B016_extra_size var730;
typedef enum {
F731 = 65536,
} B021;
B021 var732;
struct B021_extra_alignment {
char a;
B021 b;
};
struct B021_extra_alignment var733;
#pragma pack(1)
struct B021_extra_packed {
B021 a;
};
#pragma pack()
struct B021_extra_required_alignment {
char a;
struct B021_extra_packed b;
};
struct B021_extra_required_alignment var734;
struct B021_extra_size {
char a[sizeof(B021)+1];
char b;
};
struct B021_extra_size var735;
typedef enum {
F736 = 131072,
} B022;
B022 var737;
struct B022_extra_alignment {
char a;
B022 b;
};
struct B022_extra_alignment var738;
#pragma pack(1)
struct B022_extra_packed {
B022 a;
};
#pragma pack()
struct B022_extra_required_alignment {
char a;
struct B022_extra_packed b;
};
struct B022_extra_required_alignment var739;
struct B022_extra_size {
char a[sizeof(B022)+1];
char b;
};
struct B022_extra_size var740;
typedef enum {
F741 = 262144,
} B023;
B023 var742;
struct B023_extra_alignment {
char a;
B023 b;
};
struct B023_extra_alignment var743;
#pragma pack(1)
struct B023_extra_packed {
B023 a;
};
#pragma pack()
struct B023_extra_required_alignment {
char a;
struct B023_extra_packed b;
};
struct B023_extra_required_alignment var744;
struct B023_extra_size {
char a[sizeof(B023)+1];
char b;
};
struct B023_extra_size var745;
typedef enum {
F746 = 524288,
} B024;
B024 var747;
struct B024_extra_alignment {
char a;
B024 b;
};
struct B024_extra_alignment var748;
#pragma pack(1)
struct B024_extra_packed {
B024 a;
};
#pragma pack()
struct B024_extra_required_alignment {
char a;
struct B024_extra_packed b;
};
struct B024_extra_required_alignment var749;
struct B024_extra_size {
char a[sizeof(B024)+1];
char b;
};
struct B024_extra_size var750;
typedef enum {
F751 = 1048576,
} B025;
B025 var752;
struct B025_extra_alignment {
char a;
B025 b;
};
struct B025_extra_alignment var753;
#pragma pack(1)
struct B025_extra_packed {
B025 a;
};
#pragma pack()
struct B025_extra_required_alignment {
char a;
struct B025_extra_packed b;
};
struct B025_extra_required_alignment var754;
struct B025_extra_size {
char a[sizeof(B025)+1];
char b;
};
struct B025_extra_size var755;
typedef enum {
F756 = 2097152,
} B026;
B026 var757;
struct B026_extra_alignment {
char a;
B026 b;
};
struct B026_extra_alignment var758;
#pragma pack(1)
struct B026_extra_packed {
B026 a;
};
#pragma pack()
struct B026_extra_required_alignment {
char a;
struct B026_extra_packed b;
};
struct B026_extra_required_alignment var759;
struct B026_extra_size {
char a[sizeof(B026)+1];
char b;
};
struct B026_extra_size var760;
typedef enum {
F761 = 4194304,
} B027;
B027 var762;
struct B027_extra_alignment {
char a;
B027 b;
};
struct B027_extra_alignment var763;
#pragma pack(1)
struct B027_extra_packed {
B027 a;
};
#pragma pack()
struct B027_extra_required_alignment {
char a;
struct B027_extra_packed b;
};
struct B027_extra_required_alignment var764;
struct B027_extra_size {
char a[sizeof(B027)+1];
char b;
};
struct B027_extra_size var765;
typedef enum {
F766 = 8388608,
} B028;
B028 var767;
struct B028_extra_alignment {
char a;
B028 b;
};
struct B028_extra_alignment var768;
#pragma pack(1)
struct B028_extra_packed {
B028 a;
};
#pragma pack()
struct B028_extra_required_alignment {
char a;
struct B028_extra_packed b;
};
struct B028_extra_required_alignment var769;
struct B028_extra_size {
char a[sizeof(B028)+1];
char b;
};
struct B028_extra_size var770;
typedef enum {
F771 = 16777216,
} B029;
B029 var772;
struct B029_extra_alignment {
char a;
B029 b;
};
struct B029_extra_alignment var773;
#pragma pack(1)
struct B029_extra_packed {
B029 a;
};
#pragma pack()
struct B029_extra_required_alignment {
char a;
struct B029_extra_packed b;
};
struct B029_extra_required_alignment var774;
struct B029_extra_size {
char a[sizeof(B029)+1];
char b;
};
struct B029_extra_size var775;
typedef enum {
F776 = 33554432,
} B030;
B030 var777;
struct B030_extra_alignment {
char a;
B030 b;
};
struct B030_extra_alignment var778;
#pragma pack(1)
struct B030_extra_packed {
B030 a;
};
#pragma pack()
struct B030_extra_required_alignment {
char a;
struct B030_extra_packed b;
};
struct B030_extra_required_alignment var779;
struct B030_extra_size {
char a[sizeof(B030)+1];
char b;
};
struct B030_extra_size var780;
typedef enum {
F781 = 67108864,
} B031;
B031 var782;
struct B031_extra_alignment {
char a;
B031 b;
};
struct B031_extra_alignment var783;
#pragma pack(1)
struct B031_extra_packed {
B031 a;
};
#pragma pack()
struct B031_extra_required_alignment {
char a;
struct B031_extra_packed b;
};
struct B031_extra_required_alignment var784;
struct B031_extra_size {
char a[sizeof(B031)+1];
char b;
};
struct B031_extra_size var785;
typedef enum {
F786 = 134217728,
} B032;
B032 var787;
struct B032_extra_alignment {
char a;
B032 b;
};
struct B032_extra_alignment var788;
#pragma pack(1)
struct B032_extra_packed {
B032 a;
};
#pragma pack()
struct B032_extra_required_alignment {
char a;
struct B032_extra_packed b;
};
struct B032_extra_required_alignment var789;
struct B032_extra_size {
char a[sizeof(B032)+1];
char b;
};
struct B032_extra_size var790;
typedef enum {
F791 = 268435456,
} B033;
B033 var792;
struct B033_extra_alignment {
char a;
B033 b;
};
struct B033_extra_alignment var793;
#pragma pack(1)
struct B033_extra_packed {
B033 a;
};
#pragma pack()
struct B033_extra_required_alignment {
char a;
struct B033_extra_packed b;
};
struct B033_extra_required_alignment var794;
struct B033_extra_size {
char a[sizeof(B033)+1];
char b;
};
struct B033_extra_size var795;
typedef enum {
F796 = 536870912,
} B034;
B034 var797;
struct B034_extra_alignment {
char a;
B034 b;
};
struct B034_extra_alignment var798;
#pragma pack(1)
struct B034_extra_packed {
B034 a;
};
#pragma pack()
struct B034_extra_required_alignment {
char a;
struct B034_extra_packed b;
};
struct B034_extra_required_alignment var799;
struct B034_extra_size {
char a[sizeof(B034)+1];
char b;
};
struct B034_extra_size var800;
typedef enum {
F801 = 1073741824,
} B035;
B035 var802;
struct B035_extra_alignment {
char a;
B035 b;
};
struct B035_extra_alignment var803;
#pragma pack(1)
struct B035_extra_packed {
B035 a;
};
#pragma pack()
struct B035_extra_required_alignment {
char a;
struct B035_extra_packed b;
};
struct B035_extra_required_alignment var804;
struct B035_extra_size {
char a[sizeof(B035)+1];
char b;
};
struct B035_extra_size var805;
typedef enum {
F806 = 2147483648,
} B036;
B036 var807;
struct B036_extra_alignment {
char a;
B036 b;
};
struct B036_extra_alignment var808;
#pragma pack(1)
struct B036_extra_packed {
B036 a;
};
#pragma pack()
struct B036_extra_required_alignment {
char a;
struct B036_extra_packed b;
};
struct B036_extra_required_alignment var809;
struct B036_extra_size {
char a[sizeof(B036)+1];
char b;
};
struct B036_extra_size var810;
typedef enum {
F811 = 4294967296,
} B041;
B041 var812;
struct B041_extra_alignment {
char a;
B041 b;
};
struct B041_extra_alignment var813;
#pragma pack(1)
struct B041_extra_packed {
B041 a;
};
#pragma pack()
struct B041_extra_required_alignment {
char a;
struct B041_extra_packed b;
};
struct B041_extra_required_alignment var814;
struct B041_extra_size {
char a[sizeof(B041)+1];
char b;
};
struct B041_extra_size var815;
typedef enum {
F816 = 8589934592,
} B042;
B042 var817;
struct B042_extra_alignment {
char a;
B042 b;
};
struct B042_extra_alignment var818;
#pragma pack(1)
struct B042_extra_packed {
B042 a;
};
#pragma pack()
struct B042_extra_required_alignment {
char a;
struct B042_extra_packed b;
};
struct B042_extra_required_alignment var819;
struct B042_extra_size {
char a[sizeof(B042)+1];
char b;
};
struct B042_extra_size var820;
typedef enum {
F821 = 17179869184,
} B043;
B043 var822;
struct B043_extra_alignment {
char a;
B043 b;
};
struct B043_extra_alignment var823;
#pragma pack(1)
struct B043_extra_packed {
B043 a;
};
#pragma pack()
struct B043_extra_required_alignment {
char a;
struct B043_extra_packed b;
};
struct B043_extra_required_alignment var824;
struct B043_extra_size {
char a[sizeof(B043)+1];
char b;
};
struct B043_extra_size var825;
typedef enum {
F826 = 34359738368,
} B044;
B044 var827;
struct B044_extra_alignment {
char a;
B044 b;
};
struct B044_extra_alignment var828;
#pragma pack(1)
struct B044_extra_packed {
B044 a;
};
#pragma pack()
struct B044_extra_required_alignment {
char a;
struct B044_extra_packed b;
};
struct B044_extra_required_alignment var829;
struct B044_extra_size {
char a[sizeof(B044)+1];
char b;
};
struct B044_extra_size var830;
typedef enum {
F831 = 68719476736,
} B045;
B045 var832;
struct B045_extra_alignment {
char a;
B045 b;
};
struct B045_extra_alignment var833;
#pragma pack(1)
struct B045_extra_packed {
B045 a;
};
#pragma pack()
struct B045_extra_required_alignment {
char a;
struct B045_extra_packed b;
};
struct B045_extra_required_alignment var834;
struct B045_extra_size {
char a[sizeof(B045)+1];
char b;
};
struct B045_extra_size var835;
typedef enum {
F836 = 137438953472,
} B046;
B046 var837;
struct B046_extra_alignment {
char a;
B046 b;
};
struct B046_extra_alignment var838;
#pragma pack(1)
struct B046_extra_packed {
B046 a;
};
#pragma pack()
struct B046_extra_required_alignment {
char a;
struct B046_extra_packed b;
};
struct B046_extra_required_alignment var839;
struct B046_extra_size {
char a[sizeof(B046)+1];
char b;
};
struct B046_extra_size var840;
typedef enum {
F841 = 274877906944,
} B047;
B047 var842;
struct B047_extra_alignment {
char a;
B047 b;
};
struct B047_extra_alignment var843;
#pragma pack(1)
struct B047_extra_packed {
B047 a;
};
#pragma pack()
struct B047_extra_required_alignment {
char a;
struct B047_extra_packed b;
};
struct B047_extra_required_alignment var844;
struct B047_extra_size {
char a[sizeof(B047)+1];
char b;
};
struct B047_extra_size var845;
typedef enum {
F846 = 549755813888,
} B048;
B048 var847;
struct B048_extra_alignment {
char a;
B048 b;
};
struct B048_extra_alignment var848;
#pragma pack(1)
struct B048_extra_packed {
B048 a;
};
#pragma pack()
struct B048_extra_required_alignment {
char a;
struct B048_extra_packed b;
};
struct B048_extra_required_alignment var849;
struct B048_extra_size {
char a[sizeof(B048)+1];
char b;
};
struct B048_extra_size var850;
typedef enum {
F851 = 1099511627776,
} B049;
B049 var852;
struct B049_extra_alignment {
char a;
B049 b;
};
struct B049_extra_alignment var853;
#pragma pack(1)
struct B049_extra_packed {
B049 a;
};
#pragma pack()
struct B049_extra_required_alignment {
char a;
struct B049_extra_packed b;
};
struct B049_extra_required_alignment var854;
struct B049_extra_size {
char a[sizeof(B049)+1];
char b;
};
struct B049_extra_size var855;
typedef enum {
F856 = 2199023255552,
} B050;
B050 var857;
struct B050_extra_alignment {
char a;
B050 b;
};
struct B050_extra_alignment var858;
#pragma pack(1)
struct B050_extra_packed {
B050 a;
};
#pragma pack()
struct B050_extra_required_alignment {
char a;
struct B050_extra_packed b;
};
struct B050_extra_required_alignment var859;
struct B050_extra_size {
char a[sizeof(B050)+1];
char b;
};
struct B050_extra_size var860;
typedef enum {
F861 = 4398046511104,
} B051;
B051 var862;
struct B051_extra_alignment {
char a;
B051 b;
};
struct B051_extra_alignment var863;
#pragma pack(1)
struct B051_extra_packed {
B051 a;
};
#pragma pack()
struct B051_extra_required_alignment {
char a;
struct B051_extra_packed b;
};
struct B051_extra_required_alignment var864;
struct B051_extra_size {
char a[sizeof(B051)+1];
char b;
};
struct B051_extra_size var865;
typedef enum {
F866 = 8796093022208,
} B052;
B052 var867;
struct B052_extra_alignment {
char a;
B052 b;
};
struct B052_extra_alignment var868;
#pragma pack(1)
struct B052_extra_packed {
B052 a;
};
#pragma pack()
struct B052_extra_required_alignment {
char a;
struct B052_extra_packed b;
};
struct B052_extra_required_alignment var869;
struct B052_extra_size {
char a[sizeof(B052)+1];
char b;
};
struct B052_extra_size var870;
typedef enum {
F871 = 17592186044416,
} B053;
B053 var872;
struct B053_extra_alignment {
char a;
B053 b;
};
struct B053_extra_alignment var873;
#pragma pack(1)
struct B053_extra_packed {
B053 a;
};
#pragma pack()
struct B053_extra_required_alignment {
char a;
struct B053_extra_packed b;
};
struct B053_extra_required_alignment var874;
struct B053_extra_size {
char a[sizeof(B053)+1];
char b;
};
struct B053_extra_size var875;
typedef enum {
F876 = 35184372088832,
} B054;
B054 var877;
struct B054_extra_alignment {
char a;
B054 b;
};
struct B054_extra_alignment var878;
#pragma pack(1)
struct B054_extra_packed {
B054 a;
};
#pragma pack()
struct B054_extra_required_alignment {
char a;
struct B054_extra_packed b;
};
struct B054_extra_required_alignment var879;
struct B054_extra_size {
char a[sizeof(B054)+1];
char b;
};
struct B054_extra_size var880;
typedef enum {
F881 = 70368744177664,
} B055;
B055 var882;
struct B055_extra_alignment {
char a;
B055 b;
};
struct B055_extra_alignment var883;
#pragma pack(1)
struct B055_extra_packed {
B055 a;
};
#pragma pack()
struct B055_extra_required_alignment {
char a;
struct B055_extra_packed b;
};
struct B055_extra_required_alignment var884;
struct B055_extra_size {
char a[sizeof(B055)+1];
char b;
};
struct B055_extra_size var885;
typedef enum {
F886 = 140737488355328,
} B056;
B056 var887;
struct B056_extra_alignment {
char a;
B056 b;
};
struct B056_extra_alignment var888;
#pragma pack(1)
struct B056_extra_packed {
B056 a;
};
#pragma pack()
struct B056_extra_required_alignment {
char a;
struct B056_extra_packed b;
};
struct B056_extra_required_alignment var889;
struct B056_extra_size {
char a[sizeof(B056)+1];
char b;
};
struct B056_extra_size var890;
typedef enum {
F891 = 281474976710656,
} B061;
B061 var892;
struct B061_extra_alignment {
char a;
B061 b;
};
struct B061_extra_alignment var893;
#pragma pack(1)
struct B061_extra_packed {
B061 a;
};
#pragma pack()
struct B061_extra_required_alignment {
char a;
struct B061_extra_packed b;
};
struct B061_extra_required_alignment var894;
struct B061_extra_size {
char a[sizeof(B061)+1];
char b;
};
struct B061_extra_size var895;
typedef enum {
F896 = 562949953421312,
} B062;
B062 var897;
struct B062_extra_alignment {
char a;
B062 b;
};
struct B062_extra_alignment var898;
#pragma pack(1)
struct B062_extra_packed {
B062 a;
};
#pragma pack()
struct B062_extra_required_alignment {
char a;
struct B062_extra_packed b;
};
struct B062_extra_required_alignment var899;
struct B062_extra_size {
char a[sizeof(B062)+1];
char b;
};
struct B062_extra_size var900;
typedef enum {
F901 = 1125899906842624,
} B063;
B063 var902;
struct B063_extra_alignment {
char a;
B063 b;
};
struct B063_extra_alignment var903;
#pragma pack(1)
struct B063_extra_packed {
B063 a;
};
#pragma pack()
struct B063_extra_required_alignment {
char a;
struct B063_extra_packed b;
};
struct B063_extra_required_alignment var904;
struct B063_extra_size {
char a[sizeof(B063)+1];
char b;
};
struct B063_extra_size var905;
typedef enum {
F906 = 2251799813685248,
} B064;
B064 var907;
struct B064_extra_alignment {
char a;
B064 b;
};
struct B064_extra_alignment var908;
#pragma pack(1)
struct B064_extra_packed {
B064 a;
};
#pragma pack()
struct B064_extra_required_alignment {
char a;
struct B064_extra_packed b;
};
struct B064_extra_required_alignment var909;
struct B064_extra_size {
char a[sizeof(B064)+1];
char b;
};
struct B064_extra_size var910;
typedef enum {
F911 = 4503599627370496,
} B065;
B065 var912;
struct B065_extra_alignment {
char a;
B065 b;
};
struct B065_extra_alignment var913;
#pragma pack(1)
struct B065_extra_packed {
B065 a;
};
#pragma pack()
struct B065_extra_required_alignment {
char a;
struct B065_extra_packed b;
};
struct B065_extra_required_alignment var914;
struct B065_extra_size {
char a[sizeof(B065)+1];
char b;
};
struct B065_extra_size var915;
typedef enum {
F916 = 9007199254740992,
} B066;
B066 var917;
struct B066_extra_alignment {
char a;
B066 b;
};
struct B066_extra_alignment var918;
#pragma pack(1)
struct B066_extra_packed {
B066 a;
};
#pragma pack()
struct B066_extra_required_alignment {
char a;
struct B066_extra_packed b;
};
struct B066_extra_required_alignment var919;
struct B066_extra_size {
char a[sizeof(B066)+1];
char b;
};
struct B066_extra_size var920;
typedef enum {
F921 = 18014398509481984,
} B067;
B067 var922;
struct B067_extra_alignment {
char a;
B067 b;
};
struct B067_extra_alignment var923;
#pragma pack(1)
struct B067_extra_packed {
B067 a;
};
#pragma pack()
struct B067_extra_required_alignment {
char a;
struct B067_extra_packed b;
};
struct B067_extra_required_alignment var924;
struct B067_extra_size {
char a[sizeof(B067)+1];
char b;
};
struct B067_extra_size var925;
typedef enum {
F926 = 36028797018963968,
} B068;
B068 var927;
struct B068_extra_alignment {
char a;
B068 b;
};
struct B068_extra_alignment var928;
#pragma pack(1)
struct B068_extra_packed {
B068 a;
};
#pragma pack()
struct B068_extra_required_alignment {
char a;
struct B068_extra_packed b;
};
struct B068_extra_required_alignment var929;
struct B068_extra_size {
char a[sizeof(B068)+1];
char b;
};
struct B068_extra_size var930;
typedef enum {
F931 = 72057594037927936,
} B069;
B069 var932;
struct B069_extra_alignment {
char a;
B069 b;
};
struct B069_extra_alignment var933;
#pragma pack(1)
struct B069_extra_packed {
B069 a;
};
#pragma pack()
struct B069_extra_required_alignment {
char a;
struct B069_extra_packed b;
};
struct B069_extra_required_alignment var934;
struct B069_extra_size {
char a[sizeof(B069)+1];
char b;
};
struct B069_extra_size var935;
typedef enum {
F936 = 144115188075855872,
} B070;
B070 var937;
struct B070_extra_alignment {
char a;
B070 b;
};
struct B070_extra_alignment var938;
#pragma pack(1)
struct B070_extra_packed {
B070 a;
};
#pragma pack()
struct B070_extra_required_alignment {
char a;
struct B070_extra_packed b;
};
struct B070_extra_required_alignment var939;
struct B070_extra_size {
char a[sizeof(B070)+1];
char b;
};
struct B070_extra_size var940;
typedef enum {
F941 = 288230376151711744,
} B071;
B071 var942;
struct B071_extra_alignment {
char a;
B071 b;
};
struct B071_extra_alignment var943;
#pragma pack(1)
struct B071_extra_packed {
B071 a;
};
#pragma pack()
struct B071_extra_required_alignment {
char a;
struct B071_extra_packed b;
};
struct B071_extra_required_alignment var944;
struct B071_extra_size {
char a[sizeof(B071)+1];
char b;
};
struct B071_extra_size var945;
typedef enum {
F946 = 576460752303423488,
} B072;
B072 var947;
struct B072_extra_alignment {
char a;
B072 b;
};
struct B072_extra_alignment var948;
#pragma pack(1)
struct B072_extra_packed {
B072 a;
};
#pragma pack()
struct B072_extra_required_alignment {
char a;
struct B072_extra_packed b;
};
struct B072_extra_required_alignment var949;
struct B072_extra_size {
char a[sizeof(B072)+1];
char b;
};
struct B072_extra_size var950;
typedef enum {
F951 = 1152921504606846976,
} B073;
B073 var952;
struct B073_extra_alignment {
char a;
B073 b;
};
struct B073_extra_alignment var953;
#pragma pack(1)
struct B073_extra_packed {
B073 a;
};
#pragma pack()
struct B073_extra_required_alignment {
char a;
struct B073_extra_packed b;
};
struct B073_extra_required_alignment var954;
struct B073_extra_size {
char a[sizeof(B073)+1];
char b;
};
struct B073_extra_size var955;
typedef enum {
F956 = 2305843009213693952,
} B074;
B074 var957;
struct B074_extra_alignment {
char a;
B074 b;
};
struct B074_extra_alignment var958;
#pragma pack(1)
struct B074_extra_packed {
B074 a;
};
#pragma pack()
struct B074_extra_required_alignment {
char a;
struct B074_extra_packed b;
};
struct B074_extra_required_alignment var959;
struct B074_extra_size {
char a[sizeof(B074)+1];
char b;
};
struct B074_extra_size var960;
typedef enum {
F961 = 4611686018427387904,
} B075;
B075 var962;
struct B075_extra_alignment {
char a;
B075 b;
};
struct B075_extra_alignment var963;
#pragma pack(1)
struct B075_extra_packed {
B075 a;
};
#pragma pack()
struct B075_extra_required_alignment {
char a;
struct B075_extra_packed b;
};
struct B075_extra_required_alignment var964;
struct B075_extra_size {
char a[sizeof(B075)+1];
char b;
};
struct B075_extra_size var965;
typedef enum {
F966 = 9223372036854775808ULL,
} B076;
B076 var967;
struct B076_extra_alignment {
char a;
B076 b;
};
struct B076_extra_alignment var968;
#pragma pack(1)
struct B076_extra_packed {
B076 a;
};
#pragma pack()
struct B076_extra_required_alignment {
char a;
struct B076_extra_packed b;
};
struct B076_extra_required_alignment var969;
struct B076_extra_size {
char a[sizeof(B076)+1];
char b;
};
struct B076_extra_size var970;
typedef enum {
F971 = -1,
} B081;
B081 var972;
struct B081_extra_alignment {
char a;
B081 b;
};
struct B081_extra_alignment var973;
#pragma pack(1)
struct B081_extra_packed {
B081 a;
};
#pragma pack()
struct B081_extra_required_alignment {
char a;
struct B081_extra_packed b;
};
struct B081_extra_required_alignment var974;
struct B081_extra_size {
char a[sizeof(B081)+1];
char b;
};
struct B081_extra_size var975;
typedef enum {
F976 = -2,
} B082;
B082 var977;
struct B082_extra_alignment {
char a;
B082 b;
};
struct B082_extra_alignment var978;
#pragma pack(1)
struct B082_extra_packed {
B082 a;
};
#pragma pack()
struct B082_extra_required_alignment {
char a;
struct B082_extra_packed b;
};
struct B082_extra_required_alignment var979;
struct B082_extra_size {
char a[sizeof(B082)+1];
char b;
};
struct B082_extra_size var980;
typedef enum {
F981 = -4,
} B083;
B083 var982;
struct B083_extra_alignment {
char a;
B083 b;
};
struct B083_extra_alignment var983;
#pragma pack(1)
struct B083_extra_packed {
B083 a;
};
#pragma pack()
struct B083_extra_required_alignment {
char a;
struct B083_extra_packed b;
};
struct B083_extra_required_alignment var984;
struct B083_extra_size {
char a[sizeof(B083)+1];
char b;
};
struct B083_extra_size var985;
typedef enum {
F986 = -8,
} B084;
B084 var987;
struct B084_extra_alignment {
char a;
B084 b;
};
struct B084_extra_alignment var988;
#pragma pack(1)
struct B084_extra_packed {
B084 a;
};
#pragma pack()
struct B084_extra_required_alignment {
char a;
struct B084_extra_packed b;
};
struct B084_extra_required_alignment var989;
struct B084_extra_size {
char a[sizeof(B084)+1];
char b;
};
struct B084_extra_size var990;
typedef enum {
F991 = -16,
} B085;
B085 var992;
struct B085_extra_alignment {
char a;
B085 b;
};
struct B085_extra_alignment var993;
#pragma pack(1)
struct B085_extra_packed {
B085 a;
};
#pragma pack()
struct B085_extra_required_alignment {
char a;
struct B085_extra_packed b;
};
struct B085_extra_required_alignment var994;
struct B085_extra_size {
char a[sizeof(B085)+1];
char b;
};
struct B085_extra_size var995;
typedef enum {
F996 = -32,
} B086;
B086 var997;
struct B086_extra_alignment {
char a;
B086 b;
};
struct B086_extra_alignment var998;
#pragma pack(1)
struct B086_extra_packed {
B086 a;
};
#pragma pack()
struct B086_extra_required_alignment {
char a;
struct B086_extra_packed b;
};
struct B086_extra_required_alignment var999;
struct B086_extra_size {
char a[sizeof(B086)+1];
char b;
};
struct B086_extra_size var1000;
typedef enum {
F1001 = -64,
} B087;
B087 var1002;
struct B087_extra_alignment {
char a;
B087 b;
};
struct B087_extra_alignment var1003;
#pragma pack(1)
struct B087_extra_packed {
B087 a;
};
#pragma pack()
struct B087_extra_required_alignment {
char a;
struct B087_extra_packed b;
};
struct B087_extra_required_alignment var1004;
struct B087_extra_size {
char a[sizeof(B087)+1];
char b;
};
struct B087_extra_size var1005;
typedef enum {
F1006 = -128,
} B088;
B088 var1007;
struct B088_extra_alignment {
char a;
B088 b;
};
struct B088_extra_alignment var1008;
#pragma pack(1)
struct B088_extra_packed {
B088 a;
};
#pragma pack()
struct B088_extra_required_alignment {
char a;
struct B088_extra_packed b;
};
struct B088_extra_required_alignment var1009;
struct B088_extra_size {
char a[sizeof(B088)+1];
char b;
};
struct B088_extra_size var1010;
typedef enum {
F1011 = -256,
} B089;
B089 var1012;
struct B089_extra_alignment {
char a;
B089 b;
};
struct B089_extra_alignment var1013;
#pragma pack(1)
struct B089_extra_packed {
B089 a;
};
#pragma pack()
struct B089_extra_required_alignment {
char a;
struct B089_extra_packed b;
};
struct B089_extra_required_alignment var1014;
struct B089_extra_size {
char a[sizeof(B089)+1];
char b;
};
struct B089_extra_size var1015;
typedef enum {
F1016 = -512,
} B090;
B090 var1017;
struct B090_extra_alignment {
char a;
B090 b;
};
struct B090_extra_alignment var1018;
#pragma pack(1)
struct B090_extra_packed {
B090 a;
};
#pragma pack()
struct B090_extra_required_alignment {
char a;
struct B090_extra_packed b;
};
struct B090_extra_required_alignment var1019;
struct B090_extra_size {
char a[sizeof(B090)+1];
char b;
};
struct B090_extra_size var1020;
typedef enum {
F1021 = -1024,
} B091;
B091 var1022;
struct B091_extra_alignment {
char a;
B091 b;
};
struct B091_extra_alignment var1023;
#pragma pack(1)
struct B091_extra_packed {
B091 a;
};
#pragma pack()
struct B091_extra_required_alignment {
char a;
struct B091_extra_packed b;
};
struct B091_extra_required_alignment var1024;
struct B091_extra_size {
char a[sizeof(B091)+1];
char b;
};
struct B091_extra_size var1025;
typedef enum {
F1026 = -2048,
} B092;
B092 var1027;
struct B092_extra_alignment {
char a;
B092 b;
};
struct B092_extra_alignment var1028;
#pragma pack(1)
struct B092_extra_packed {
B092 a;
};
#pragma pack()
struct B092_extra_required_alignment {
char a;
struct B092_extra_packed b;
};
struct B092_extra_required_alignment var1029;
struct B092_extra_size {
char a[sizeof(B092)+1];
char b;
};
struct B092_extra_size var1030;
typedef enum {
F1031 = -4096,
} B093;
B093 var1032;
struct B093_extra_alignment {
char a;
B093 b;
};
struct B093_extra_alignment var1033;
#pragma pack(1)
struct B093_extra_packed {
B093 a;
};
#pragma pack()
struct B093_extra_required_alignment {
char a;
struct B093_extra_packed b;
};
struct B093_extra_required_alignment var1034;
struct B093_extra_size {
char a[sizeof(B093)+1];
char b;
};
struct B093_extra_size var1035;
typedef enum {
F1036 = -8192,
} B094;
B094 var1037;
struct B094_extra_alignment {
char a;
B094 b;
};
struct B094_extra_alignment var1038;
#pragma pack(1)
struct B094_extra_packed {
B094 a;
};
#pragma pack()
struct B094_extra_required_alignment {
char a;
struct B094_extra_packed b;
};
struct B094_extra_required_alignment var1039;
struct B094_extra_size {
char a[sizeof(B094)+1];
char b;
};
struct B094_extra_size var1040;
typedef enum {
F1041 = -16384,
} B095;
B095 var1042;
struct B095_extra_alignment {
char a;
B095 b;
};
struct B095_extra_alignment var1043;
#pragma pack(1)
struct B095_extra_packed {
B095 a;
};
#pragma pack()
struct B095_extra_required_alignment {
char a;
struct B095_extra_packed b;
};
struct B095_extra_required_alignment var1044;
struct B095_extra_size {
char a[sizeof(B095)+1];
char b;
};
struct B095_extra_size var1045;
typedef enum {
F1046 = -32768,
} B096;
B096 var1047;
struct B096_extra_alignment {
char a;
B096 b;
};
struct B096_extra_alignment var1048;
#pragma pack(1)
struct B096_extra_packed {
B096 a;
};
#pragma pack()
struct B096_extra_required_alignment {
char a;
struct B096_extra_packed b;
};
struct B096_extra_required_alignment var1049;
struct B096_extra_size {
char a[sizeof(B096)+1];
char b;
};
struct B096_extra_size var1050;
typedef enum {
F1051 = -65536,
} B101;
B101 var1052;
struct B101_extra_alignment {
char a;
B101 b;
};
struct B101_extra_alignment var1053;
#pragma pack(1)
struct B101_extra_packed {
B101 a;
};
#pragma pack()
struct B101_extra_required_alignment {
char a;
struct B101_extra_packed b;
};
struct B101_extra_required_alignment var1054;
struct B101_extra_size {
char a[sizeof(B101)+1];
char b;
};
struct B101_extra_size var1055;
typedef enum {
F1056 = -131072,
} B102;
B102 var1057;
struct B102_extra_alignment {
char a;
B102 b;
};
struct B102_extra_alignment var1058;
#pragma pack(1)
struct B102_extra_packed {
B102 a;
};
#pragma pack()
struct B102_extra_required_alignment {
char a;
struct B102_extra_packed b;
};
struct B102_extra_required_alignment var1059;
struct B102_extra_size {
char a[sizeof(B102)+1];
char b;
};
struct B102_extra_size var1060;
typedef enum {
F1061 = -262144,
} B103;
B103 var1062;
struct B103_extra_alignment {
char a;
B103 b;
};
struct B103_extra_alignment var1063;
#pragma pack(1)
struct B103_extra_packed {
B103 a;
};
#pragma pack()
struct B103_extra_required_alignment {
char a;
struct B103_extra_packed b;
};
struct B103_extra_required_alignment var1064;
struct B103_extra_size {
char a[sizeof(B103)+1];
char b;
};
struct B103_extra_size var1065;
typedef enum {
F1066 = -524288,
} B104;
B104 var1067;
struct B104_extra_alignment {
char a;
B104 b;
};
struct B104_extra_alignment var1068;
#pragma pack(1)
struct B104_extra_packed {
B104 a;
};
#pragma pack()
struct B104_extra_required_alignment {
char a;
struct B104_extra_packed b;
};
struct B104_extra_required_alignment var1069;
struct B104_extra_size {
char a[sizeof(B104)+1];
char b;
};
struct B104_extra_size var1070;
typedef enum {
F1071 = -1048576,
} B105;
B105 var1072;
struct B105_extra_alignment {
char a;
B105 b;
};
struct B105_extra_alignment var1073;
#pragma pack(1)
struct B105_extra_packed {
B105 a;
};
#pragma pack()
struct B105_extra_required_alignment {
char a;
struct B105_extra_packed b;
};
struct B105_extra_required_alignment var1074;
struct B105_extra_size {
char a[sizeof(B105)+1];
char b;
};
struct B105_extra_size var1075;
typedef enum {
F1076 = -2097152,
} B106;
B106 var1077;
struct B106_extra_alignment {
char a;
B106 b;
};
struct B106_extra_alignment var1078;
#pragma pack(1)
struct B106_extra_packed {
B106 a;
};
#pragma pack()
struct B106_extra_required_alignment {
char a;
struct B106_extra_packed b;
};
struct B106_extra_required_alignment var1079;
struct B106_extra_size {
char a[sizeof(B106)+1];
char b;
};
struct B106_extra_size var1080;
typedef enum {
F1081 = -4194304,
} B107;
B107 var1082;
struct B107_extra_alignment {
char a;
B107 b;
};
struct B107_extra_alignment var1083;
#pragma pack(1)
struct B107_extra_packed {
B107 a;
};
#pragma pack()
struct B107_extra_required_alignment {
char a;
struct B107_extra_packed b;
};
struct B107_extra_required_alignment var1084;
struct B107_extra_size {
char a[sizeof(B107)+1];
char b;
};
struct B107_extra_size var1085;
typedef enum {
F1086 = -8388608,
} B108;
B108 var1087;
struct B108_extra_alignment {
char a;
B108 b;
};
struct B108_extra_alignment var1088;
#pragma pack(1)
struct B108_extra_packed {
B108 a;
};
#pragma pack()
struct B108_extra_required_alignment {
char a;
struct B108_extra_packed b;
};
struct B108_extra_required_alignment var1089;
struct B108_extra_size {
char a[sizeof(B108)+1];
char b;
};
struct B108_extra_size var1090;
typedef enum {
F1091 = -16777216,
} B109;
B109 var1092;
struct B109_extra_alignment {
char a;
B109 b;
};
struct B109_extra_alignment var1093;
#pragma pack(1)
struct B109_extra_packed {
B109 a;
};
#pragma pack()
struct B109_extra_required_alignment {
char a;
struct B109_extra_packed b;
};
struct B109_extra_required_alignment var1094;
struct B109_extra_size {
char a[sizeof(B109)+1];
char b;
};
struct B109_extra_size var1095;
typedef enum {
F1096 = -33554432,
} B110;
B110 var1097;
struct B110_extra_alignment {
char a;
B110 b;
};
struct B110_extra_alignment var1098;
#pragma pack(1)
struct B110_extra_packed {
B110 a;
};
#pragma pack()
struct B110_extra_required_alignment {
char a;
struct B110_extra_packed b;
};
struct B110_extra_required_alignment var1099;
struct B110_extra_size {
char a[sizeof(B110)+1];
char b;
};
struct B110_extra_size var1100;
typedef enum {
F1101 = -67108864,
} B111;
B111 var1102;
struct B111_extra_alignment {
char a;
B111 b;
};
struct B111_extra_alignment var1103;
#pragma pack(1)
struct B111_extra_packed {
B111 a;
};
#pragma pack()
struct B111_extra_required_alignment {
char a;
struct B111_extra_packed b;
};
struct B111_extra_required_alignment var1104;
struct B111_extra_size {
char a[sizeof(B111)+1];
char b;
};
struct B111_extra_size var1105;
typedef enum {
F1106 = -134217728,
} B112;
B112 var1107;
struct B112_extra_alignment {
char a;
B112 b;
};
struct B112_extra_alignment var1108;
#pragma pack(1)
struct B112_extra_packed {
B112 a;
};
#pragma pack()
struct B112_extra_required_alignment {
char a;
struct B112_extra_packed b;
};
struct B112_extra_required_alignment var1109;
struct B112_extra_size {
char a[sizeof(B112)+1];
char b;
};
struct B112_extra_size var1110;
typedef enum {
F1111 = -268435456,
} B113;
B113 var1112;
struct B113_extra_alignment {
char a;
B113 b;
};
struct B113_extra_alignment var1113;
#pragma pack(1)
struct B113_extra_packed {
B113 a;
};
#pragma pack()
struct B113_extra_required_alignment {
char a;
struct B113_extra_packed b;
};
struct B113_extra_required_alignment var1114;
struct B113_extra_size {
char a[sizeof(B113)+1];
char b;
};
struct B113_extra_size var1115;
typedef enum {
F1116 = -536870912,
} B114;
B114 var1117;
struct B114_extra_alignment {
char a;
B114 b;
};
struct B114_extra_alignment var1118;
#pragma pack(1)
struct B114_extra_packed {
B114 a;
};
#pragma pack()
struct B114_extra_required_alignment {
char a;
struct B114_extra_packed b;
};
struct B114_extra_required_alignment var1119;
struct B114_extra_size {
char a[sizeof(B114)+1];
char b;
};
struct B114_extra_size var1120;
typedef enum {
F1121 = -1073741824,
} B115;
B115 var1122;
struct B115_extra_alignment {
char a;
B115 b;
};
struct B115_extra_alignment var1123;
#pragma pack(1)
struct B115_extra_packed {
B115 a;
};
#pragma pack()
struct B115_extra_required_alignment {
char a;
struct B115_extra_packed b;
};
struct B115_extra_required_alignment var1124;
struct B115_extra_size {
char a[sizeof(B115)+1];
char b;
};
struct B115_extra_size var1125;
typedef enum {
F1126 = -2147483648,
} B116;
B116 var1127;
struct B116_extra_alignment {
char a;
B116 b;
};
struct B116_extra_alignment var1128;
#pragma pack(1)
struct B116_extra_packed {
B116 a;
};
#pragma pack()
struct B116_extra_required_alignment {
char a;
struct B116_extra_packed b;
};
struct B116_extra_required_alignment var1129;
struct B116_extra_size {
char a[sizeof(B116)+1];
char b;
};
struct B116_extra_size var1130;
typedef enum {
F1131 = -4294967296,
} B121;
B121 var1132;
struct B121_extra_alignment {
char a;
B121 b;
};
struct B121_extra_alignment var1133;
#pragma pack(1)
struct B121_extra_packed {
B121 a;
};
#pragma pack()
struct B121_extra_required_alignment {
char a;
struct B121_extra_packed b;
};
struct B121_extra_required_alignment var1134;
struct B121_extra_size {
char a[sizeof(B121)+1];
char b;
};
struct B121_extra_size var1135;
typedef enum {
F1136 = -8589934592,
} B122;
B122 var1137;
struct B122_extra_alignment {
char a;
B122 b;
};
struct B122_extra_alignment var1138;
#pragma pack(1)
struct B122_extra_packed {
B122 a;
};
#pragma pack()
struct B122_extra_required_alignment {
char a;
struct B122_extra_packed b;
};
struct B122_extra_required_alignment var1139;
struct B122_extra_size {
char a[sizeof(B122)+1];
char b;
};
struct B122_extra_size var1140;
typedef enum {
F1141 = -17179869184,
} B123;
B123 var1142;
struct B123_extra_alignment {
char a;
B123 b;
};
struct B123_extra_alignment var1143;
#pragma pack(1)
struct B123_extra_packed {
B123 a;
};
#pragma pack()
struct B123_extra_required_alignment {
char a;
struct B123_extra_packed b;
};
struct B123_extra_required_alignment var1144;
struct B123_extra_size {
char a[sizeof(B123)+1];
char b;
};
struct B123_extra_size var1145;
typedef enum {
F1146 = -34359738368,
} B124;
B124 var1147;
struct B124_extra_alignment {
char a;
B124 b;
};
struct B124_extra_alignment var1148;
#pragma pack(1)
struct B124_extra_packed {
B124 a;
};
#pragma pack()
struct B124_extra_required_alignment {
char a;
struct B124_extra_packed b;
};
struct B124_extra_required_alignment var1149;
struct B124_extra_size {
char a[sizeof(B124)+1];
char b;
};
struct B124_extra_size var1150;
typedef enum {
F1151 = -68719476736,
} B125;
B125 var1152;
struct B125_extra_alignment {
char a;
B125 b;
};
struct B125_extra_alignment var1153;
#pragma pack(1)
struct B125_extra_packed {
B125 a;
};
#pragma pack()
struct B125_extra_required_alignment {
char a;
struct B125_extra_packed b;
};
struct B125_extra_required_alignment var1154;
struct B125_extra_size {
char a[sizeof(B125)+1];
char b;
};
struct B125_extra_size var1155;
typedef enum {
F1156 = -137438953472,
} B126;
B126 var1157;
struct B126_extra_alignment {
char a;
B126 b;
};
struct B126_extra_alignment var1158;
#pragma pack(1)
struct B126_extra_packed {
B126 a;
};
#pragma pack()
struct B126_extra_required_alignment {
char a;
struct B126_extra_packed b;
};
struct B126_extra_required_alignment var1159;
struct B126_extra_size {
char a[sizeof(B126)+1];
char b;
};
struct B126_extra_size var1160;
typedef enum {
F1161 = -274877906944,
} B127;
B127 var1162;
struct B127_extra_alignment {
char a;
B127 b;
};
struct B127_extra_alignment var1163;
#pragma pack(1)
struct B127_extra_packed {
B127 a;
};
#pragma pack()
struct B127_extra_required_alignment {
char a;
struct B127_extra_packed b;
};
struct B127_extra_required_alignment var1164;
struct B127_extra_size {
char a[sizeof(B127)+1];
char b;
};
struct B127_extra_size var1165;
typedef enum {
F1166 = -549755813888,
} B128;
B128 var1167;
struct B128_extra_alignment {
char a;
B128 b;
};
struct B128_extra_alignment var1168;
#pragma pack(1)
struct B128_extra_packed {
B128 a;
};
#pragma pack()
struct B128_extra_required_alignment {
char a;
struct B128_extra_packed b;
};
struct B128_extra_required_alignment var1169;
struct B128_extra_size {
char a[sizeof(B128)+1];
char b;
};
struct B128_extra_size var1170;
typedef enum {
F1171 = -1099511627776,
} B129;
B129 var1172;
struct B129_extra_alignment {
char a;
B129 b;
};
struct B129_extra_alignment var1173;
#pragma pack(1)
struct B129_extra_packed {
B129 a;
};
#pragma pack()
struct B129_extra_required_alignment {
char a;
struct B129_extra_packed b;
};
struct B129_extra_required_alignment var1174;
struct B129_extra_size {
char a[sizeof(B129)+1];
char b;
};
struct B129_extra_size var1175;
typedef enum {
F1176 = -2199023255552,
} B130;
B130 var1177;
struct B130_extra_alignment {
char a;
B130 b;
};
struct B130_extra_alignment var1178;
#pragma pack(1)
struct B130_extra_packed {
B130 a;
};
#pragma pack()
struct B130_extra_required_alignment {
char a;
struct B130_extra_packed b;
};
struct B130_extra_required_alignment var1179;
struct B130_extra_size {
char a[sizeof(B130)+1];
char b;
};
struct B130_extra_size var1180;
typedef enum {
F1181 = -4398046511104,
} B131;
B131 var1182;
struct B131_extra_alignment {
char a;
B131 b;
};
struct B131_extra_alignment var1183;
#pragma pack(1)
struct B131_extra_packed {
B131 a;
};
#pragma pack()
struct B131_extra_required_alignment {
char a;
struct B131_extra_packed b;
};
struct B131_extra_required_alignment var1184;
struct B131_extra_size {
char a[sizeof(B131)+1];
char b;
};
struct B131_extra_size var1185;
typedef enum {
F1186 = -8796093022208,
} B132;
B132 var1187;
struct B132_extra_alignment {
char a;
B132 b;
};
struct B132_extra_alignment var1188;
#pragma pack(1)
struct B132_extra_packed {
B132 a;
};
#pragma pack()
struct B132_extra_required_alignment {
char a;
struct B132_extra_packed b;
};
struct B132_extra_required_alignment var1189;
struct B132_extra_size {
char a[sizeof(B132)+1];
char b;
};
struct B132_extra_size var1190;
typedef enum {
F1191 = -17592186044416,
} B133;
B133 var1192;
struct B133_extra_alignment {
char a;
B133 b;
};
struct B133_extra_alignment var1193;
#pragma pack(1)
struct B133_extra_packed {
B133 a;
};
#pragma pack()
struct B133_extra_required_alignment {
char a;
struct B133_extra_packed b;
};
struct B133_extra_required_alignment var1194;
struct B133_extra_size {
char a[sizeof(B133)+1];
char b;
};
struct B133_extra_size var1195;
typedef enum {
F1196 = -35184372088832,
} B134;
B134 var1197;
struct B134_extra_alignment {
char a;
B134 b;
};
struct B134_extra_alignment var1198;
#pragma pack(1)
struct B134_extra_packed {
B134 a;
};
#pragma pack()
struct B134_extra_required_alignment {
char a;
struct B134_extra_packed b;
};
struct B134_extra_required_alignment var1199;
struct B134_extra_size {
char a[sizeof(B134)+1];
char b;
};
struct B134_extra_size var1200;
typedef enum {
F1201 = -70368744177664,
} B135;
B135 var1202;
struct B135_extra_alignment {
char a;
B135 b;
};
struct B135_extra_alignment var1203;
#pragma pack(1)
struct B135_extra_packed {
B135 a;
};
#pragma pack()
struct B135_extra_required_alignment {
char a;
struct B135_extra_packed b;
};
struct B135_extra_required_alignment var1204;
struct B135_extra_size {
char a[sizeof(B135)+1];
char b;
};
struct B135_extra_size var1205;
typedef enum {
F1206 = -140737488355328,
} B136;
B136 var1207;
struct B136_extra_alignment {
char a;
B136 b;
};
struct B136_extra_alignment var1208;
#pragma pack(1)
struct B136_extra_packed {
B136 a;
};
#pragma pack()
struct B136_extra_required_alignment {
char a;
struct B136_extra_packed b;
};
struct B136_extra_required_alignment var1209;
struct B136_extra_size {
char a[sizeof(B136)+1];
char b;
};
struct B136_extra_size var1210;
typedef enum {
F1211 = -281474976710656,
} B141;
B141 var1212;
struct B141_extra_alignment {
char a;
B141 b;
};
struct B141_extra_alignment var1213;
#pragma pack(1)
struct B141_extra_packed {
B141 a;
};
#pragma pack()
struct B141_extra_required_alignment {
char a;
struct B141_extra_packed b;
};
struct B141_extra_required_alignment var1214;
struct B141_extra_size {
char a[sizeof(B141)+1];
char b;
};
struct B141_extra_size var1215;
typedef enum {
F1216 = -562949953421312,
} B142;
B142 var1217;
struct B142_extra_alignment {
char a;
B142 b;
};
struct B142_extra_alignment var1218;
#pragma pack(1)
struct B142_extra_packed {
B142 a;
};
#pragma pack()
struct B142_extra_required_alignment {
char a;
struct B142_extra_packed b;
};
struct B142_extra_required_alignment var1219;
struct B142_extra_size {
char a[sizeof(B142)+1];
char b;
};
struct B142_extra_size var1220;
typedef enum {
F1221 = -1125899906842624,
} B143;
B143 var1222;
struct B143_extra_alignment {
char a;
B143 b;
};
struct B143_extra_alignment var1223;
#pragma pack(1)
struct B143_extra_packed {
B143 a;
};
#pragma pack()
struct B143_extra_required_alignment {
char a;
struct B143_extra_packed b;
};
struct B143_extra_required_alignment var1224;
struct B143_extra_size {
char a[sizeof(B143)+1];
char b;
};
struct B143_extra_size var1225;
typedef enum {
F1226 = -2251799813685248,
} B144;
B144 var1227;
struct B144_extra_alignment {
char a;
B144 b;
};
struct B144_extra_alignment var1228;
#pragma pack(1)
struct B144_extra_packed {
B144 a;
};
#pragma pack()
struct B144_extra_required_alignment {
char a;
struct B144_extra_packed b;
};
struct B144_extra_required_alignment var1229;
struct B144_extra_size {
char a[sizeof(B144)+1];
char b;
};
struct B144_extra_size var1230;
typedef enum {
F1231 = -4503599627370496,
} B145;
B145 var1232;
struct B145_extra_alignment {
char a;
B145 b;
};
struct B145_extra_alignment var1233;
#pragma pack(1)
struct B145_extra_packed {
B145 a;
};
#pragma pack()
struct B145_extra_required_alignment {
char a;
struct B145_extra_packed b;
};
struct B145_extra_required_alignment var1234;
struct B145_extra_size {
char a[sizeof(B145)+1];
char b;
};
struct B145_extra_size var1235;
typedef enum {
F1236 = -9007199254740992,
} B146;
B146 var1237;
struct B146_extra_alignment {
char a;
B146 b;
};
struct B146_extra_alignment var1238;
#pragma pack(1)
struct B146_extra_packed {
B146 a;
};
#pragma pack()
struct B146_extra_required_alignment {
char a;
struct B146_extra_packed b;
};
struct B146_extra_required_alignment var1239;
struct B146_extra_size {
char a[sizeof(B146)+1];
char b;
};
struct B146_extra_size var1240;
typedef enum {
F1241 = -18014398509481984,
} B147;
B147 var1242;
struct B147_extra_alignment {
char a;
B147 b;
};
struct B147_extra_alignment var1243;
#pragma pack(1)
struct B147_extra_packed {
B147 a;
};
#pragma pack()
struct B147_extra_required_alignment {
char a;
struct B147_extra_packed b;
};
struct B147_extra_required_alignment var1244;
struct B147_extra_size {
char a[sizeof(B147)+1];
char b;
};
struct B147_extra_size var1245;
typedef enum {
F1246 = -36028797018963968,
} B148;
B148 var1247;
struct B148_extra_alignment {
char a;
B148 b;
};
struct B148_extra_alignment var1248;
#pragma pack(1)
struct B148_extra_packed {
B148 a;
};
#pragma pack()
struct B148_extra_required_alignment {
char a;
struct B148_extra_packed b;
};
struct B148_extra_required_alignment var1249;
struct B148_extra_size {
char a[sizeof(B148)+1];
char b;
};
struct B148_extra_size var1250;
typedef enum {
F1251 = -72057594037927936,
} B149;
B149 var1252;
struct B149_extra_alignment {
char a;
B149 b;
};
struct B149_extra_alignment var1253;
#pragma pack(1)
struct B149_extra_packed {
B149 a;
};
#pragma pack()
struct B149_extra_required_alignment {
char a;
struct B149_extra_packed b;
};
struct B149_extra_required_alignment var1254;
struct B149_extra_size {
char a[sizeof(B149)+1];
char b;
};
struct B149_extra_size var1255;
typedef enum {
F1256 = -144115188075855872,
} B150;
B150 var1257;
struct B150_extra_alignment {
char a;
B150 b;
};
struct B150_extra_alignment var1258;
#pragma pack(1)
struct B150_extra_packed {
B150 a;
};
#pragma pack()
struct B150_extra_required_alignment {
char a;
struct B150_extra_packed b;
};
struct B150_extra_required_alignment var1259;
struct B150_extra_size {
char a[sizeof(B150)+1];
char b;
};
struct B150_extra_size var1260;
typedef enum {
F1261 = -288230376151711744,
} B151;
B151 var1262;
struct B151_extra_alignment {
char a;
B151 b;
};
struct B151_extra_alignment var1263;
#pragma pack(1)
struct B151_extra_packed {
B151 a;
};
#pragma pack()
struct B151_extra_required_alignment {
char a;
struct B151_extra_packed b;
};
struct B151_extra_required_alignment var1264;
struct B151_extra_size {
char a[sizeof(B151)+1];
char b;
};
struct B151_extra_size var1265;
typedef enum {
F1266 = -576460752303423488,
} B152;
B152 var1267;
struct B152_extra_alignment {
char a;
B152 b;
};
struct B152_extra_alignment var1268;
#pragma pack(1)
struct B152_extra_packed {
B152 a;
};
#pragma pack()
struct B152_extra_required_alignment {
char a;
struct B152_extra_packed b;
};
struct B152_extra_required_alignment var1269;
struct B152_extra_size {
char a[sizeof(B152)+1];
char b;
};
struct B152_extra_size var1270;
typedef enum {
F1271 = -1152921504606846976,
} B153;
B153 var1272;
struct B153_extra_alignment {
char a;
B153 b;
};
struct B153_extra_alignment var1273;
#pragma pack(1)
struct B153_extra_packed {
B153 a;
};
#pragma pack()
struct B153_extra_required_alignment {
char a;
struct B153_extra_packed b;
};
struct B153_extra_required_alignment var1274;
struct B153_extra_size {
char a[sizeof(B153)+1];
char b;
};
struct B153_extra_size var1275;
typedef enum {
F1276 = -2305843009213693952,
} B154;
B154 var1277;
struct B154_extra_alignment {
char a;
B154 b;
};
struct B154_extra_alignment var1278;
#pragma pack(1)
struct B154_extra_packed {
B154 a;
};
#pragma pack()
struct B154_extra_required_alignment {
char a;
struct B154_extra_packed b;
};
struct B154_extra_required_alignment var1279;
struct B154_extra_size {
char a[sizeof(B154)+1];
char b;
};
struct B154_extra_size var1280;
typedef enum {
F1281 = -4611686018427387904,
} B155;
B155 var1282;
struct B155_extra_alignment {
char a;
B155 b;
};
struct B155_extra_alignment var1283;
#pragma pack(1)
struct B155_extra_packed {
B155 a;
};
#pragma pack()
struct B155_extra_required_alignment {
char a;
struct B155_extra_packed b;
};
struct B155_extra_required_alignment var1284;
struct B155_extra_size {
char a[sizeof(B155)+1];
char b;
};
struct B155_extra_size var1285;
typedef enum {
F1286 = -9223372036854775808ULL,
} B156;
B156 var1287;
struct B156_extra_alignment {
char a;
B156 b;
};
struct B156_extra_alignment var1288;
#pragma pack(1)
struct B156_extra_packed {
B156 a;
};
#pragma pack()
struct B156_extra_required_alignment {
char a;
struct B156_extra_packed b;
};
struct B156_extra_required_alignment var1289;
struct B156_extra_size {
char a[sizeof(B156)+1];
char b;
};
struct B156_extra_size var1290;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|x86-i686-windows-gnu:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") I686PcWindowsGnu|Some("x86-i686-windows-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A000) == 1, "");
_Static_assert(_Alignof(A000) == 1, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 3, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
_Static_assert(sizeof(A001) == 1, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 3, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
_Static_assert(sizeof(A002) == 1, "");
_Static_assert(_Alignof(A002) == 1, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 3, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
_Static_assert(sizeof(A003) == 1, "");
_Static_assert(_Alignof(A003) == 1, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 3, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
_Static_assert(sizeof(A004) == 1, "");
_Static_assert(_Alignof(A004) == 1, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 3, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 1, "");
_Static_assert(_Alignof(A005) == 1, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 3, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
_Static_assert(sizeof(A006) == 1, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 3, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
_Static_assert(sizeof(A007) == 1, "");
_Static_assert(_Alignof(A007) == 1, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 3, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
_Static_assert(sizeof(A008) == 1, "");
_Static_assert(_Alignof(A008) == 1, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 3, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
_Static_assert(sizeof(A009) == 2, "");
_Static_assert(_Alignof(A009) == 2, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A009_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 4, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
_Static_assert(sizeof(A010) == 2, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 4, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
_Static_assert(sizeof(A011) == 2, "");
_Static_assert(_Alignof(A011) == 2, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 4, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
_Static_assert(sizeof(A012) == 2, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 4, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
_Static_assert(sizeof(A013) == 2, "");
_Static_assert(_Alignof(A013) == 2, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A013_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 4, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
_Static_assert(sizeof(A014) == 2, "");
_Static_assert(_Alignof(A014) == 2, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A014_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 4, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
_Static_assert(sizeof(A015) == 2, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 4, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
_Static_assert(sizeof(A016) == 2, "");
_Static_assert(_Alignof(A016) == 2, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 4, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
_Static_assert(sizeof(A021) == 4, "");
_Static_assert(_Alignof(A021) == 4, "");
_Static_assert(sizeof(struct A021_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A021_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A021_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A021_extra_packed) == 1, "");
_Static_assert(sizeof(struct A021_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A021_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A021_extra_size) == 6, "");
_Static_assert(_Alignof(struct A021_extra_size) == 1, "");
_Static_assert(sizeof(A022) == 4, "");
_Static_assert(_Alignof(A022) == 4, "");
_Static_assert(sizeof(struct A022_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A022_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A022_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A022_extra_packed) == 1, "");
_Static_assert(sizeof(struct A022_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A022_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A022_extra_size) == 6, "");
_Static_assert(_Alignof(struct A022_extra_size) == 1, "");
_Static_assert(sizeof(A023) == 4, "");
_Static_assert(_Alignof(A023) == 4, "");
_Static_assert(sizeof(struct A023_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A023_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A023_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A023_extra_packed) == 1, "");
_Static_assert(sizeof(struct A023_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A023_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A023_extra_size) == 6, "");
_Static_assert(_Alignof(struct A023_extra_size) == 1, "");
_Static_assert(sizeof(A024) == 4, "");
_Static_assert(_Alignof(A024) == 4, "");
_Static_assert(sizeof(struct A024_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A024_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A024_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A024_extra_packed) == 1, "");
_Static_assert(sizeof(struct A024_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A024_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A024_extra_size) == 6, "");
_Static_assert(_Alignof(struct A024_extra_size) == 1, "");
_Static_assert(sizeof(A025) == 4, "");
_Static_assert(_Alignof(A025) == 4, "");
_Static_assert(sizeof(struct A025_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A025_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A025_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A025_extra_packed) == 1, "");
_Static_assert(sizeof(struct A025_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A025_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A025_extra_size) == 6, "");
_Static_assert(_Alignof(struct A025_extra_size) == 1, "");
_Static_assert(sizeof(A026) == 4, "");
_Static_assert(_Alignof(A026) == 4, "");
_Static_assert(sizeof(struct A026_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A026_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A026_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A026_extra_packed) == 1, "");
_Static_assert(sizeof(struct A026_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A026_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A026_extra_size) == 6, "");
_Static_assert(_Alignof(struct A026_extra_size) == 1, "");
_Static_assert(sizeof(A027) == 4, "");
_Static_assert(_Alignof(A027) == 4, "");
_Static_assert(sizeof(struct A027_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A027_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A027_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A027_extra_packed) == 1, "");
_Static_assert(sizeof(struct A027_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A027_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A027_extra_size) == 6, "");
_Static_assert(_Alignof(struct A027_extra_size) == 1, "");
_Static_assert(sizeof(A028) == 4, "");
_Static_assert(_Alignof(A028) == 4, "");
_Static_assert(sizeof(struct A028_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A028_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A028_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A028_extra_packed) == 1, "");
_Static_assert(sizeof(struct A028_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A028_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A028_extra_size) == 6, "");
_Static_assert(_Alignof(struct A028_extra_size) == 1, "");
_Static_assert(sizeof(A029) == 4, "");
_Static_assert(_Alignof(A029) == 4, "");
_Static_assert(sizeof(struct A029_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A029_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A029_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A029_extra_packed) == 1, "");
_Static_assert(sizeof(struct A029_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A029_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A029_extra_size) == 6, "");
_Static_assert(_Alignof(struct A029_extra_size) == 1, "");
_Static_assert(sizeof(A030) == 4, "");
_Static_assert(_Alignof(A030) == 4, "");
_Static_assert(sizeof(struct A030_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A030_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A030_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A030_extra_packed) == 1, "");
_Static_assert(sizeof(struct A030_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A030_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A030_extra_size) == 6, "");
_Static_assert(_Alignof(struct A030_extra_size) == 1, "");
_Static_assert(sizeof(A031) == 4, "");
_Static_assert(_Alignof(A031) == 4, "");
_Static_assert(sizeof(struct A031_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A031_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A031_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A031_extra_packed) == 1, "");
_Static_assert(sizeof(struct A031_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A031_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A031_extra_size) == 6, "");
_Static_assert(_Alignof(struct A031_extra_size) == 1, "");
_Static_assert(sizeof(A032) == 4, "");
_Static_assert(_Alignof(A032) == 4, "");
_Static_assert(sizeof(struct A032_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A032_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A032_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A032_extra_packed) == 1, "");
_Static_assert(sizeof(struct A032_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A032_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A032_extra_size) == 6, "");
_Static_assert(_Alignof(struct A032_extra_size) == 1, "");
_Static_assert(sizeof(A033) == 4, "");
_Static_assert(_Alignof(A033) == 4, "");
_Static_assert(sizeof(struct A033_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A033_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A033_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A033_extra_packed) == 1, "");
_Static_assert(sizeof(struct A033_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A033_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A033_extra_size) == 6, "");
_Static_assert(_Alignof(struct A033_extra_size) == 1, "");
_Static_assert(sizeof(A034) == 4, "");
_Static_assert(_Alignof(A034) == 4, "");
_Static_assert(sizeof(struct A034_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A034_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A034_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A034_extra_packed) == 1, "");
_Static_assert(sizeof(struct A034_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A034_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A034_extra_size) == 6, "");
_Static_assert(_Alignof(struct A034_extra_size) == 1, "");
_Static_assert(sizeof(A035) == 4, "");
_Static_assert(_Alignof(A035) == 4, "");
_Static_assert(sizeof(struct A035_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A035_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A035_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A035_extra_packed) == 1, "");
_Static_assert(sizeof(struct A035_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A035_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A035_extra_size) == 6, "");
_Static_assert(_Alignof(struct A035_extra_size) == 1, "");
_Static_assert(sizeof(A036) == 4, "");
_Static_assert(_Alignof(A036) == 4, "");
_Static_assert(sizeof(struct A036_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A036_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A036_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A036_extra_packed) == 1, "");
_Static_assert(sizeof(struct A036_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A036_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A036_extra_size) == 6, "");
_Static_assert(_Alignof(struct A036_extra_size) == 1, "");
_Static_assert(sizeof(A041) == 8, "");
_Static_assert(_Alignof(A041) == 8, "");
_Static_assert(sizeof(struct A041_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A041_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A041_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A041_extra_packed) == 1, "");
_Static_assert(sizeof(struct A041_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A041_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A041_extra_size) == 10, "");
_Static_assert(_Alignof(struct A041_extra_size) == 1, "");
_Static_assert(sizeof(A042) == 8, "");
_Static_assert(_Alignof(A042) == 8, "");
_Static_assert(sizeof(struct A042_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A042_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A042_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A042_extra_packed) == 1, "");
_Static_assert(sizeof(struct A042_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A042_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A042_extra_size) == 10, "");
_Static_assert(_Alignof(struct A042_extra_size) == 1, "");
_Static_assert(sizeof(A043) == 8, "");
_Static_assert(_Alignof(A043) == 8, "");
_Static_assert(sizeof(struct A043_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A043_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A043_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A043_extra_packed) == 1, "");
_Static_assert(sizeof(struct A043_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A043_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A043_extra_size) == 10, "");
_Static_assert(_Alignof(struct A043_extra_size) == 1, "");
_Static_assert(sizeof(A044) == 8, "");
_Static_assert(_Alignof(A044) == 8, "");
_Static_assert(sizeof(struct A044_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A044_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A044_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A044_extra_packed) == 1, "");
_Static_assert(sizeof(struct A044_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A044_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A044_extra_size) == 10, "");
_Static_assert(_Alignof(struct A044_extra_size) == 1, "");
_Static_assert(sizeof(A045) == 8, "");
_Static_assert(_Alignof(A045) == 8, "");
_Static_assert(sizeof(struct A045_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A045_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A045_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A045_extra_packed) == 1, "");
_Static_assert(sizeof(struct A045_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A045_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A045_extra_size) == 10, "");
_Static_assert(_Alignof(struct A045_extra_size) == 1, "");
_Static_assert(sizeof(A046) == 8, "");
_Static_assert(_Alignof(A046) == 8, "");
_Static_assert(sizeof(struct A046_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A046_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A046_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A046_extra_packed) == 1, "");
_Static_assert(sizeof(struct A046_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A046_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A046_extra_size) == 10, "");
_Static_assert(_Alignof(struct A046_extra_size) == 1, "");
_Static_assert(sizeof(A047) == 8, "");
_Static_assert(_Alignof(A047) == 8, "");
_Static_assert(sizeof(struct A047_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A047_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A047_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A047_extra_packed) == 1, "");
_Static_assert(sizeof(struct A047_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A047_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A047_extra_size) == 10, "");
_Static_assert(_Alignof(struct A047_extra_size) == 1, "");
_Static_assert(sizeof(A048) == 8, "");
_Static_assert(_Alignof(A048) == 8, "");
_Static_assert(sizeof(struct A048_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A048_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A048_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A048_extra_packed) == 1, "");
_Static_assert(sizeof(struct A048_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A048_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A048_extra_size) == 10, "");
_Static_assert(_Alignof(struct A048_extra_size) == 1, "");
_Static_assert(sizeof(A049) == 8, "");
_Static_assert(_Alignof(A049) == 8, "");
_Static_assert(sizeof(struct A049_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A049_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A049_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A049_extra_packed) == 1, "");
_Static_assert(sizeof(struct A049_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A049_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A049_extra_size) == 10, "");
_Static_assert(_Alignof(struct A049_extra_size) == 1, "");
_Static_assert(sizeof(A050) == 8, "");
_Static_assert(_Alignof(A050) == 8, "");
_Static_assert(sizeof(struct A050_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A050_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A050_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A050_extra_packed) == 1, "");
_Static_assert(sizeof(struct A050_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A050_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A050_extra_size) == 10, "");
_Static_assert(_Alignof(struct A050_extra_size) == 1, "");
_Static_assert(sizeof(A051) == 8, "");
_Static_assert(_Alignof(A051) == 8, "");
_Static_assert(sizeof(struct A051_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A051_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A051_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A051_extra_packed) == 1, "");
_Static_assert(sizeof(struct A051_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A051_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A051_extra_size) == 10, "");
_Static_assert(_Alignof(struct A051_extra_size) == 1, "");
_Static_assert(sizeof(A052) == 8, "");
_Static_assert(_Alignof(A052) == 8, "");
_Static_assert(sizeof(struct A052_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A052_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A052_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A052_extra_packed) == 1, "");
_Static_assert(sizeof(struct A052_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A052_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A052_extra_size) == 10, "");
_Static_assert(_Alignof(struct A052_extra_size) == 1, "");
_Static_assert(sizeof(A053) == 8, "");
_Static_assert(_Alignof(A053) == 8, "");
_Static_assert(sizeof(struct A053_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A053_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A053_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A053_extra_packed) == 1, "");
_Static_assert(sizeof(struct A053_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A053_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A053_extra_size) == 10, "");
_Static_assert(_Alignof(struct A053_extra_size) == 1, "");
_Static_assert(sizeof(A054) == 8, "");
_Static_assert(_Alignof(A054) == 8, "");
_Static_assert(sizeof(struct A054_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A054_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A054_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A054_extra_packed) == 1, "");
_Static_assert(sizeof(struct A054_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A054_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A054_extra_size) == 10, "");
_Static_assert(_Alignof(struct A054_extra_size) == 1, "");
_Static_assert(sizeof(A055) == 8, "");
_Static_assert(_Alignof(A055) == 8, "");
_Static_assert(sizeof(struct A055_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A055_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A055_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A055_extra_packed) == 1, "");
_Static_assert(sizeof(struct A055_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A055_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A055_extra_size) == 10, "");
_Static_assert(_Alignof(struct A055_extra_size) == 1, "");
_Static_assert(sizeof(A056) == 8, "");
_Static_assert(_Alignof(A056) == 8, "");
_Static_assert(sizeof(struct A056_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A056_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A056_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A056_extra_packed) == 1, "");
_Static_assert(sizeof(struct A056_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A056_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A056_extra_size) == 10, "");
_Static_assert(_Alignof(struct A056_extra_size) == 1, "");
_Static_assert(sizeof(A061) == 8, "");
_Static_assert(_Alignof(A061) == 8, "");
_Static_assert(sizeof(struct A061_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A061_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A061_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A061_extra_packed) == 1, "");
_Static_assert(sizeof(struct A061_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A061_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A061_extra_size) == 10, "");
_Static_assert(_Alignof(struct A061_extra_size) == 1, "");
_Static_assert(sizeof(A062) == 8, "");
_Static_assert(_Alignof(A062) == 8, "");
_Static_assert(sizeof(struct A062_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A062_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A062_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A062_extra_packed) == 1, "");
_Static_assert(sizeof(struct A062_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A062_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A062_extra_size) == 10, "");
_Static_assert(_Alignof(struct A062_extra_size) == 1, "");
_Static_assert(sizeof(A063) == 8, "");
_Static_assert(_Alignof(A063) == 8, "");
_Static_assert(sizeof(struct A063_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A063_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A063_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A063_extra_packed) == 1, "");
_Static_assert(sizeof(struct A063_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A063_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A063_extra_size) == 10, "");
_Static_assert(_Alignof(struct A063_extra_size) == 1, "");
_Static_assert(sizeof(A064) == 8, "");
_Static_assert(_Alignof(A064) == 8, "");
_Static_assert(sizeof(struct A064_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A064_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A064_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A064_extra_packed) == 1, "");
_Static_assert(sizeof(struct A064_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A064_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A064_extra_size) == 10, "");
_Static_assert(_Alignof(struct A064_extra_size) == 1, "");
_Static_assert(sizeof(A065) == 8, "");
_Static_assert(_Alignof(A065) == 8, "");
_Static_assert(sizeof(struct A065_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A065_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A065_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A065_extra_packed) == 1, "");
_Static_assert(sizeof(struct A065_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A065_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A065_extra_size) == 10, "");
_Static_assert(_Alignof(struct A065_extra_size) == 1, "");
_Static_assert(sizeof(A066) == 8, "");
_Static_assert(_Alignof(A066) == 8, "");
_Static_assert(sizeof(struct A066_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A066_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A066_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A066_extra_packed) == 1, "");
_Static_assert(sizeof(struct A066_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A066_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A066_extra_size) == 10, "");
_Static_assert(_Alignof(struct A066_extra_size) == 1, "");
_Static_assert(sizeof(A067) == 8, "");
_Static_assert(_Alignof(A067) == 8, "");
_Static_assert(sizeof(struct A067_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A067_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A067_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A067_extra_packed) == 1, "");
_Static_assert(sizeof(struct A067_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A067_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A067_extra_size) == 10, "");
_Static_assert(_Alignof(struct A067_extra_size) == 1, "");
_Static_assert(sizeof(A068) == 8, "");
_Static_assert(_Alignof(A068) == 8, "");
_Static_assert(sizeof(struct A068_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A068_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A068_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A068_extra_packed) == 1, "");
_Static_assert(sizeof(struct A068_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A068_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A068_extra_size) == 10, "");
_Static_assert(_Alignof(struct A068_extra_size) == 1, "");
_Static_assert(sizeof(A069) == 8, "");
_Static_assert(_Alignof(A069) == 8, "");
_Static_assert(sizeof(struct A069_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A069_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A069_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A069_extra_packed) == 1, "");
_Static_assert(sizeof(struct A069_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A069_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A069_extra_size) == 10, "");
_Static_assert(_Alignof(struct A069_extra_size) == 1, "");
_Static_assert(sizeof(A070) == 8, "");
_Static_assert(_Alignof(A070) == 8, "");
_Static_assert(sizeof(struct A070_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A070_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A070_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A070_extra_packed) == 1, "");
_Static_assert(sizeof(struct A070_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A070_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A070_extra_size) == 10, "");
_Static_assert(_Alignof(struct A070_extra_size) == 1, "");
_Static_assert(sizeof(A071) == 8, "");
_Static_assert(_Alignof(A071) == 8, "");
_Static_assert(sizeof(struct A071_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A071_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A071_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A071_extra_packed) == 1, "");
_Static_assert(sizeof(struct A071_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A071_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A071_extra_size) == 10, "");
_Static_assert(_Alignof(struct A071_extra_size) == 1, "");
_Static_assert(sizeof(A072) == 8, "");
_Static_assert(_Alignof(A072) == 8, "");
_Static_assert(sizeof(struct A072_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A072_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A072_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A072_extra_packed) == 1, "");
_Static_assert(sizeof(struct A072_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A072_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A072_extra_size) == 10, "");
_Static_assert(_Alignof(struct A072_extra_size) == 1, "");
_Static_assert(sizeof(A073) == 8, "");
_Static_assert(_Alignof(A073) == 8, "");
_Static_assert(sizeof(struct A073_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A073_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A073_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A073_extra_packed) == 1, "");
_Static_assert(sizeof(struct A073_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A073_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A073_extra_size) == 10, "");
_Static_assert(_Alignof(struct A073_extra_size) == 1, "");
_Static_assert(sizeof(A074) == 8, "");
_Static_assert(_Alignof(A074) == 8, "");
_Static_assert(sizeof(struct A074_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A074_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A074_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A074_extra_packed) == 1, "");
_Static_assert(sizeof(struct A074_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A074_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A074_extra_size) == 10, "");
_Static_assert(_Alignof(struct A074_extra_size) == 1, "");
_Static_assert(sizeof(A075) == 8, "");
_Static_assert(_Alignof(A075) == 8, "");
_Static_assert(sizeof(struct A075_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A075_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A075_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A075_extra_packed) == 1, "");
_Static_assert(sizeof(struct A075_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A075_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A075_extra_size) == 10, "");
_Static_assert(_Alignof(struct A075_extra_size) == 1, "");
_Static_assert(sizeof(A076) == 8, "");
_Static_assert(_Alignof(A076) == 8, "");
_Static_assert(sizeof(struct A076_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A076_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A076_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A076_extra_packed) == 1, "");
_Static_assert(sizeof(struct A076_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A076_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A076_extra_size) == 10, "");
_Static_assert(_Alignof(struct A076_extra_size) == 1, "");
_Static_assert(sizeof(A081) == 1, "");
_Static_assert(_Alignof(A081) == 1, "");
_Static_assert(sizeof(struct A081_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A081_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A081_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A081_extra_packed) == 1, "");
_Static_assert(sizeof(struct A081_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A081_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A081_extra_size) == 3, "");
_Static_assert(_Alignof(struct A081_extra_size) == 1, "");
_Static_assert(sizeof(A082) == 1, "");
_Static_assert(_Alignof(A082) == 1, "");
_Static_assert(sizeof(struct A082_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A082_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A082_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A082_extra_packed) == 1, "");
_Static_assert(sizeof(struct A082_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A082_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A082_extra_size) == 3, "");
_Static_assert(_Alignof(struct A082_extra_size) == 1, "");
_Static_assert(sizeof(A083) == 1, "");
_Static_assert(_Alignof(A083) == 1, "");
_Static_assert(sizeof(struct A083_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A083_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A083_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A083_extra_packed) == 1, "");
_Static_assert(sizeof(struct A083_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A083_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A083_extra_size) == 3, "");
_Static_assert(_Alignof(struct A083_extra_size) == 1, "");
_Static_assert(sizeof(A084) == 1, "");
_Static_assert(_Alignof(A084) == 1, "");
_Static_assert(sizeof(struct A084_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A084_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A084_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A084_extra_packed) == 1, "");
_Static_assert(sizeof(struct A084_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A084_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A084_extra_size) == 3, "");
_Static_assert(_Alignof(struct A084_extra_size) == 1, "");
_Static_assert(sizeof(A085) == 1, "");
_Static_assert(_Alignof(A085) == 1, "");
_Static_assert(sizeof(struct A085_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A085_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A085_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A085_extra_packed) == 1, "");
_Static_assert(sizeof(struct A085_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A085_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A085_extra_size) == 3, "");
_Static_assert(_Alignof(struct A085_extra_size) == 1, "");
_Static_assert(sizeof(A086) == 1, "");
_Static_assert(_Alignof(A086) == 1, "");
_Static_assert(sizeof(struct A086_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A086_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A086_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A086_extra_packed) == 1, "");
_Static_assert(sizeof(struct A086_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A086_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A086_extra_size) == 3, "");
_Static_assert(_Alignof(struct A086_extra_size) == 1, "");
_Static_assert(sizeof(A087) == 1, "");
_Static_assert(_Alignof(A087) == 1, "");
_Static_assert(sizeof(struct A087_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A087_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A087_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A087_extra_packed) == 1, "");
_Static_assert(sizeof(struct A087_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A087_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A087_extra_size) == 3, "");
_Static_assert(_Alignof(struct A087_extra_size) == 1, "");
_Static_assert(sizeof(A088) == 1, "");
_Static_assert(_Alignof(A088) == 1, "");
_Static_assert(sizeof(struct A088_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A088_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A088_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A088_extra_packed) == 1, "");
_Static_assert(sizeof(struct A088_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A088_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A088_extra_size) == 3, "");
_Static_assert(_Alignof(struct A088_extra_size) == 1, "");
_Static_assert(sizeof(A089) == 2, "");
_Static_assert(_Alignof(A089) == 2, "");
_Static_assert(sizeof(struct A089_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A089_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A089_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A089_extra_packed) == 1, "");
_Static_assert(sizeof(struct A089_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A089_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A089_extra_size) == 4, "");
_Static_assert(_Alignof(struct A089_extra_size) == 1, "");
_Static_assert(sizeof(A090) == 2, "");
_Static_assert(_Alignof(A090) == 2, "");
_Static_assert(sizeof(struct A090_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A090_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A090_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A090_extra_packed) == 1, "");
_Static_assert(sizeof(struct A090_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A090_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A090_extra_size) == 4, "");
_Static_assert(_Alignof(struct A090_extra_size) == 1, "");
_Static_assert(sizeof(A091) == 2, "");
_Static_assert(_Alignof(A091) == 2, "");
_Static_assert(sizeof(struct A091_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A091_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A091_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A091_extra_packed) == 1, "");
_Static_assert(sizeof(struct A091_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A091_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A091_extra_size) == 4, "");
_Static_assert(_Alignof(struct A091_extra_size) == 1, "");
_Static_assert(sizeof(A092) == 2, "");
_Static_assert(_Alignof(A092) == 2, "");
_Static_assert(sizeof(struct A092_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A092_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A092_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A092_extra_packed) == 1, "");
_Static_assert(sizeof(struct A092_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A092_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A092_extra_size) == 4, "");
_Static_assert(_Alignof(struct A092_extra_size) == 1, "");
_Static_assert(sizeof(A093) == 2, "");
_Static_assert(_Alignof(A093) == 2, "");
_Static_assert(sizeof(struct A093_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A093_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A093_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A093_extra_packed) == 1, "");
_Static_assert(sizeof(struct A093_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A093_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A093_extra_size) == 4, "");
_Static_assert(_Alignof(struct A093_extra_size) == 1, "");
_Static_assert(sizeof(A094) == 2, "");
_Static_assert(_Alignof(A094) == 2, "");
_Static_assert(sizeof(struct A094_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A094_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A094_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A094_extra_packed) == 1, "");
_Static_assert(sizeof(struct A094_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A094_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A094_extra_size) == 4, "");
_Static_assert(_Alignof(struct A094_extra_size) == 1, "");
_Static_assert(sizeof(A095) == 2, "");
_Static_assert(_Alignof(A095) == 2, "");
_Static_assert(sizeof(struct A095_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A095_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A095_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A095_extra_packed) == 1, "");
_Static_assert(sizeof(struct A095_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A095_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A095_extra_size) == 4, "");
_Static_assert(_Alignof(struct A095_extra_size) == 1, "");
_Static_assert(sizeof(A096) == 2, "");
_Static_assert(_Alignof(A096) == 2, "");
_Static_assert(sizeof(struct A096_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A096_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A096_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A096_extra_packed) == 1, "");
_Static_assert(sizeof(struct A096_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A096_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A096_extra_size) == 4, "");
_Static_assert(_Alignof(struct A096_extra_size) == 1, "");
_Static_assert(sizeof(A101) == 4, "");
_Static_assert(_Alignof(A101) == 4, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 6, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
_Static_assert(sizeof(A102) == 4, "");
_Static_assert(_Alignof(A102) == 4, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 6, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
_Static_assert(sizeof(A103) == 4, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 6, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
_Static_assert(sizeof(A104) == 4, "");
_Static_assert(_Alignof(A104) == 4, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 6, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 4, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
_Static_assert(sizeof(A106) == 4, "");
_Static_assert(_Alignof(A106) == 4, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 6, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
_Static_assert(sizeof(A107) == 4, "");
_Static_assert(_Alignof(A107) == 4, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 6, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
_Static_assert(sizeof(A108) == 4, "");
_Static_assert(_Alignof(A108) == 4, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 6, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
_Static_assert(sizeof(A109) == 4, "");
_Static_assert(_Alignof(A109) == 4, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 6, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
_Static_assert(sizeof(A110) == 4, "");
_Static_assert(_Alignof(A110) == 4, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 6, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
_Static_assert(sizeof(A111) == 4, "");
_Static_assert(_Alignof(A111) == 4, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 6, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
_Static_assert(sizeof(A112) == 4, "");
_Static_assert(_Alignof(A112) == 4, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 6, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
_Static_assert(sizeof(A113) == 4, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 6, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
_Static_assert(sizeof(A114) == 4, "");
_Static_assert(_Alignof(A114) == 4, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 6, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
_Static_assert(sizeof(A115) == 4, "");
_Static_assert(_Alignof(A115) == 4, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 6, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
_Static_assert(sizeof(A116) == 4, "");
_Static_assert(_Alignof(A116) == 4, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 6, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
_Static_assert(sizeof(A121) == 8, "");
_Static_assert(_Alignof(A121) == 8, "");
_Static_assert(sizeof(struct A121_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A121_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A121_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A121_extra_packed) == 1, "");
_Static_assert(sizeof(struct A121_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A121_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A121_extra_size) == 10, "");
_Static_assert(_Alignof(struct A121_extra_size) == 1, "");
_Static_assert(sizeof(A122) == 8, "");
_Static_assert(_Alignof(A122) == 8, "");
_Static_assert(sizeof(struct A122_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A122_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A122_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A122_extra_packed) == 1, "");
_Static_assert(sizeof(struct A122_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A122_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A122_extra_size) == 10, "");
_Static_assert(_Alignof(struct A122_extra_size) == 1, "");
_Static_assert(sizeof(A123) == 8, "");
_Static_assert(_Alignof(A123) == 8, "");
_Static_assert(sizeof(struct A123_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A123_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A123_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A123_extra_packed) == 1, "");
_Static_assert(sizeof(struct A123_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A123_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A123_extra_size) == 10, "");
_Static_assert(_Alignof(struct A123_extra_size) == 1, "");
_Static_assert(sizeof(A124) == 8, "");
_Static_assert(_Alignof(A124) == 8, "");
_Static_assert(sizeof(struct A124_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A124_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A124_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A124_extra_packed) == 1, "");
_Static_assert(sizeof(struct A124_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A124_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A124_extra_size) == 10, "");
_Static_assert(_Alignof(struct A124_extra_size) == 1, "");
_Static_assert(sizeof(A125) == 8, "");
_Static_assert(_Alignof(A125) == 8, "");
_Static_assert(sizeof(struct A125_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A125_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A125_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A125_extra_packed) == 1, "");
_Static_assert(sizeof(struct A125_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A125_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A125_extra_size) == 10, "");
_Static_assert(_Alignof(struct A125_extra_size) == 1, "");
_Static_assert(sizeof(A126) == 8, "");
_Static_assert(_Alignof(A126) == 8, "");
_Static_assert(sizeof(struct A126_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A126_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A126_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A126_extra_packed) == 1, "");
_Static_assert(sizeof(struct A126_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A126_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A126_extra_size) == 10, "");
_Static_assert(_Alignof(struct A126_extra_size) == 1, "");
_Static_assert(sizeof(A127) == 8, "");
_Static_assert(_Alignof(A127) == 8, "");
_Static_assert(sizeof(struct A127_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A127_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A127_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A127_extra_packed) == 1, "");
_Static_assert(sizeof(struct A127_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A127_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A127_extra_size) == 10, "");
_Static_assert(_Alignof(struct A127_extra_size) == 1, "");
_Static_assert(sizeof(A128) == 8, "");
_Static_assert(_Alignof(A128) == 8, "");
_Static_assert(sizeof(struct A128_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A128_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A128_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A128_extra_packed) == 1, "");
_Static_assert(sizeof(struct A128_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A128_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A128_extra_size) == 10, "");
_Static_assert(_Alignof(struct A128_extra_size) == 1, "");
_Static_assert(sizeof(A129) == 8, "");
_Static_assert(_Alignof(A129) == 8, "");
_Static_assert(sizeof(struct A129_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A129_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A129_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A129_extra_packed) == 1, "");
_Static_assert(sizeof(struct A129_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A129_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A129_extra_size) == 10, "");
_Static_assert(_Alignof(struct A129_extra_size) == 1, "");
_Static_assert(sizeof(A130) == 8, "");
_Static_assert(_Alignof(A130) == 8, "");
_Static_assert(sizeof(struct A130_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A130_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A130_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A130_extra_packed) == 1, "");
_Static_assert(sizeof(struct A130_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A130_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A130_extra_size) == 10, "");
_Static_assert(_Alignof(struct A130_extra_size) == 1, "");
_Static_assert(sizeof(A131) == 8, "");
_Static_assert(_Alignof(A131) == 8, "");
_Static_assert(sizeof(struct A131_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A131_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A131_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A131_extra_packed) == 1, "");
_Static_assert(sizeof(struct A131_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A131_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A131_extra_size) == 10, "");
_Static_assert(_Alignof(struct A131_extra_size) == 1, "");
_Static_assert(sizeof(A132) == 8, "");
_Static_assert(_Alignof(A132) == 8, "");
_Static_assert(sizeof(struct A132_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A132_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A132_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A132_extra_packed) == 1, "");
_Static_assert(sizeof(struct A132_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A132_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A132_extra_size) == 10, "");
_Static_assert(_Alignof(struct A132_extra_size) == 1, "");
_Static_assert(sizeof(A133) == 8, "");
_Static_assert(_Alignof(A133) == 8, "");
_Static_assert(sizeof(struct A133_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A133_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A133_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A133_extra_packed) == 1, "");
_Static_assert(sizeof(struct A133_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A133_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A133_extra_size) == 10, "");
_Static_assert(_Alignof(struct A133_extra_size) == 1, "");
_Static_assert(sizeof(A134) == 8, "");
_Static_assert(_Alignof(A134) == 8, "");
_Static_assert(sizeof(struct A134_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A134_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A134_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A134_extra_packed) == 1, "");
_Static_assert(sizeof(struct A134_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A134_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A134_extra_size) == 10, "");
_Static_assert(_Alignof(struct A134_extra_size) == 1, "");
_Static_assert(sizeof(A135) == 8, "");
_Static_assert(_Alignof(A135) == 8, "");
_Static_assert(sizeof(struct A135_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A135_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A135_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A135_extra_packed) == 1, "");
_Static_assert(sizeof(struct A135_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A135_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A135_extra_size) == 10, "");
_Static_assert(_Alignof(struct A135_extra_size) == 1, "");
_Static_assert(sizeof(A136) == 8, "");
_Static_assert(_Alignof(A136) == 8, "");
_Static_assert(sizeof(struct A136_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A136_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A136_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A136_extra_packed) == 1, "");
_Static_assert(sizeof(struct A136_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A136_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A136_extra_size) == 10, "");
_Static_assert(_Alignof(struct A136_extra_size) == 1, "");
_Static_assert(sizeof(A141) == 8, "");
_Static_assert(_Alignof(A141) == 8, "");
_Static_assert(sizeof(struct A141_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A141_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A141_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A141_extra_packed) == 1, "");
_Static_assert(sizeof(struct A141_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A141_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A141_extra_size) == 10, "");
_Static_assert(_Alignof(struct A141_extra_size) == 1, "");
_Static_assert(sizeof(A142) == 8, "");
_Static_assert(_Alignof(A142) == 8, "");
_Static_assert(sizeof(struct A142_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A142_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A142_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A142_extra_packed) == 1, "");
_Static_assert(sizeof(struct A142_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A142_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A142_extra_size) == 10, "");
_Static_assert(_Alignof(struct A142_extra_size) == 1, "");
_Static_assert(sizeof(A143) == 8, "");
_Static_assert(_Alignof(A143) == 8, "");
_Static_assert(sizeof(struct A143_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A143_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A143_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A143_extra_packed) == 1, "");
_Static_assert(sizeof(struct A143_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A143_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A143_extra_size) == 10, "");
_Static_assert(_Alignof(struct A143_extra_size) == 1, "");
_Static_assert(sizeof(A144) == 8, "");
_Static_assert(_Alignof(A144) == 8, "");
_Static_assert(sizeof(struct A144_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A144_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A144_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A144_extra_packed) == 1, "");
_Static_assert(sizeof(struct A144_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A144_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A144_extra_size) == 10, "");
_Static_assert(_Alignof(struct A144_extra_size) == 1, "");
_Static_assert(sizeof(A145) == 8, "");
_Static_assert(_Alignof(A145) == 8, "");
_Static_assert(sizeof(struct A145_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A145_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A145_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A145_extra_packed) == 1, "");
_Static_assert(sizeof(struct A145_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A145_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A145_extra_size) == 10, "");
_Static_assert(_Alignof(struct A145_extra_size) == 1, "");
_Static_assert(sizeof(A146) == 8, "");
_Static_assert(_Alignof(A146) == 8, "");
_Static_assert(sizeof(struct A146_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A146_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A146_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A146_extra_packed) == 1, "");
_Static_assert(sizeof(struct A146_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A146_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A146_extra_size) == 10, "");
_Static_assert(_Alignof(struct A146_extra_size) == 1, "");
_Static_assert(sizeof(A147) == 8, "");
_Static_assert(_Alignof(A147) == 8, "");
_Static_assert(sizeof(struct A147_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A147_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A147_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A147_extra_packed) == 1, "");
_Static_assert(sizeof(struct A147_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A147_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A147_extra_size) == 10, "");
_Static_assert(_Alignof(struct A147_extra_size) == 1, "");
_Static_assert(sizeof(A148) == 8, "");
_Static_assert(_Alignof(A148) == 8, "");
_Static_assert(sizeof(struct A148_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A148_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A148_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A148_extra_packed) == 1, "");
_Static_assert(sizeof(struct A148_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A148_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A148_extra_size) == 10, "");
_Static_assert(_Alignof(struct A148_extra_size) == 1, "");
_Static_assert(sizeof(A149) == 8, "");
_Static_assert(_Alignof(A149) == 8, "");
_Static_assert(sizeof(struct A149_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A149_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A149_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A149_extra_packed) == 1, "");
_Static_assert(sizeof(struct A149_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A149_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A149_extra_size) == 10, "");
_Static_assert(_Alignof(struct A149_extra_size) == 1, "");
_Static_assert(sizeof(A150) == 8, "");
_Static_assert(_Alignof(A150) == 8, "");
_Static_assert(sizeof(struct A150_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A150_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A150_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A150_extra_packed) == 1, "");
_Static_assert(sizeof(struct A150_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A150_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A150_extra_size) == 10, "");
_Static_assert(_Alignof(struct A150_extra_size) == 1, "");
_Static_assert(sizeof(A151) == 8, "");
_Static_assert(_Alignof(A151) == 8, "");
_Static_assert(sizeof(struct A151_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A151_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A151_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A151_extra_packed) == 1, "");
_Static_assert(sizeof(struct A151_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A151_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A151_extra_size) == 10, "");
_Static_assert(_Alignof(struct A151_extra_size) == 1, "");
_Static_assert(sizeof(A152) == 8, "");
_Static_assert(_Alignof(A152) == 8, "");
_Static_assert(sizeof(struct A152_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A152_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A152_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A152_extra_packed) == 1, "");
_Static_assert(sizeof(struct A152_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A152_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A152_extra_size) == 10, "");
_Static_assert(_Alignof(struct A152_extra_size) == 1, "");
_Static_assert(sizeof(A153) == 8, "");
_Static_assert(_Alignof(A153) == 8, "");
_Static_assert(sizeof(struct A153_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A153_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A153_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A153_extra_packed) == 1, "");
_Static_assert(sizeof(struct A153_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A153_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A153_extra_size) == 10, "");
_Static_assert(_Alignof(struct A153_extra_size) == 1, "");
_Static_assert(sizeof(A154) == 8, "");
_Static_assert(_Alignof(A154) == 8, "");
_Static_assert(sizeof(struct A154_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A154_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A154_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A154_extra_packed) == 1, "");
_Static_assert(sizeof(struct A154_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A154_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A154_extra_size) == 10, "");
_Static_assert(_Alignof(struct A154_extra_size) == 1, "");
_Static_assert(sizeof(A155) == 8, "");
_Static_assert(_Alignof(A155) == 8, "");
_Static_assert(sizeof(struct A155_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A155_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A155_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A155_extra_packed) == 1, "");
_Static_assert(sizeof(struct A155_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A155_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A155_extra_size) == 10, "");
_Static_assert(_Alignof(struct A155_extra_size) == 1, "");
_Static_assert(sizeof(A156) == 8, "");
_Static_assert(_Alignof(A156) == 8, "");
_Static_assert(sizeof(struct A156_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A156_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A156_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A156_extra_packed) == 1, "");
_Static_assert(sizeof(struct A156_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A156_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A156_extra_size) == 10, "");
_Static_assert(_Alignof(struct A156_extra_size) == 1, "");
_Static_assert(sizeof(B000) == 4, "");
_Static_assert(_Alignof(B000) == 4, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 6, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
_Static_assert(sizeof(B001) == 4, "");
_Static_assert(_Alignof(B001) == 4, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B001_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 6, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
_Static_assert(sizeof(B002) == 4, "");
_Static_assert(_Alignof(B002) == 4, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B002_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 6, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 4, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 4, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 4, "");
_Static_assert(_Alignof(B005) == 4, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B005_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 6, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
_Static_assert(sizeof(B006) == 4, "");
_Static_assert(_Alignof(B006) == 4, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B006_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 6, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
_Static_assert(sizeof(B007) == 4, "");
_Static_assert(_Alignof(B007) == 4, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B007_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 6, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
_Static_assert(sizeof(B008) == 4, "");
_Static_assert(_Alignof(B008) == 4, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B008_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 6, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
_Static_assert(sizeof(B009) == 4, "");
_Static_assert(_Alignof(B009) == 4, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B009_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 6, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
_Static_assert(sizeof(B010) == 4, "");
_Static_assert(_Alignof(B010) == 4, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B010_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 6, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
_Static_assert(sizeof(B011) == 4, "");
_Static_assert(_Alignof(B011) == 4, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B011_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 6, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
_Static_assert(sizeof(B012) == 4, "");
_Static_assert(_Alignof(B012) == 4, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B012_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 6, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
_Static_assert(sizeof(B013) == 4, "");
_Static_assert(_Alignof(B013) == 4, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B013_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 6, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
_Static_assert(sizeof(B014) == 4, "");
_Static_assert(_Alignof(B014) == 4, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B014_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 6, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
_Static_assert(sizeof(B015) == 4, "");
_Static_assert(_Alignof(B015) == 4, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B015_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 6, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
_Static_assert(sizeof(B016) == 4, "");
_Static_assert(_Alignof(B016) == 4, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B016_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 6, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
_Static_assert(sizeof(B021) == 4, "");
_Static_assert(_Alignof(B021) == 4, "");
_Static_assert(sizeof(struct B021_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B021_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B021_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B021_extra_packed) == 1, "");
_Static_assert(sizeof(struct B021_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B021_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B021_extra_size) == 6, "");
_Static_assert(_Alignof(struct B021_extra_size) == 1, "");
_Static_assert(sizeof(B022) == 4, "");
_Static_assert(_Alignof(B022) == 4, "");
_Static_assert(sizeof(struct B022_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B022_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B022_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B022_extra_packed) == 1, "");
_Static_assert(sizeof(struct B022_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B022_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B022_extra_size) == 6, "");
_Static_assert(_Alignof(struct B022_extra_size) == 1, "");
_Static_assert(sizeof(B023) == 4, "");
_Static_assert(_Alignof(B023) == 4, "");
_Static_assert(sizeof(struct B023_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B023_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B023_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B023_extra_packed) == 1, "");
_Static_assert(sizeof(struct B023_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B023_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B023_extra_size) == 6, "");
_Static_assert(_Alignof(struct B023_extra_size) == 1, "");
_Static_assert(sizeof(B024) == 4, "");
_Static_assert(_Alignof(B024) == 4, "");
_Static_assert(sizeof(struct B024_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B024_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B024_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B024_extra_packed) == 1, "");
_Static_assert(sizeof(struct B024_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B024_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B024_extra_size) == 6, "");
_Static_assert(_Alignof(struct B024_extra_size) == 1, "");
_Static_assert(sizeof(B025) == 4, "");
_Static_assert(_Alignof(B025) == 4, "");
_Static_assert(sizeof(struct B025_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B025_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B025_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B025_extra_packed) == 1, "");
_Static_assert(sizeof(struct B025_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B025_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B025_extra_size) == 6, "");
_Static_assert(_Alignof(struct B025_extra_size) == 1, "");
_Static_assert(sizeof(B026) == 4, "");
_Static_assert(_Alignof(B026) == 4, "");
_Static_assert(sizeof(struct B026_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B026_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B026_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B026_extra_packed) == 1, "");
_Static_assert(sizeof(struct B026_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B026_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B026_extra_size) == 6, "");
_Static_assert(_Alignof(struct B026_extra_size) == 1, "");
_Static_assert(sizeof(B027) == 4, "");
_Static_assert(_Alignof(B027) == 4, "");
_Static_assert(sizeof(struct B027_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B027_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B027_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B027_extra_packed) == 1, "");
_Static_assert(sizeof(struct B027_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B027_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B027_extra_size) == 6, "");
_Static_assert(_Alignof(struct B027_extra_size) == 1, "");
_Static_assert(sizeof(B028) == 4, "");
_Static_assert(_Alignof(B028) == 4, "");
_Static_assert(sizeof(struct B028_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B028_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B028_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B028_extra_packed) == 1, "");
_Static_assert(sizeof(struct B028_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B028_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B028_extra_size) == 6, "");
_Static_assert(_Alignof(struct B028_extra_size) == 1, "");
_Static_assert(sizeof(B029) == 4, "");
_Static_assert(_Alignof(B029) == 4, "");
_Static_assert(sizeof(struct B029_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B029_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B029_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B029_extra_packed) == 1, "");
_Static_assert(sizeof(struct B029_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B029_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B029_extra_size) == 6, "");
_Static_assert(_Alignof(struct B029_extra_size) == 1, "");
_Static_assert(sizeof(B030) == 4, "");
_Static_assert(_Alignof(B030) == 4, "");
_Static_assert(sizeof(struct B030_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B030_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B030_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B030_extra_packed) == 1, "");
_Static_assert(sizeof(struct B030_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B030_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B030_extra_size) == 6, "");
_Static_assert(_Alignof(struct B030_extra_size) == 1, "");
_Static_assert(sizeof(B031) == 4, "");
_Static_assert(_Alignof(B031) == 4, "");
_Static_assert(sizeof(struct B031_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B031_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B031_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B031_extra_packed) == 1, "");
_Static_assert(sizeof(struct B031_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B031_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B031_extra_size) == 6, "");
_Static_assert(_Alignof(struct B031_extra_size) == 1, "");
_Static_assert(sizeof(B032) == 4, "");
_Static_assert(_Alignof(B032) == 4, "");
_Static_assert(sizeof(struct B032_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B032_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B032_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B032_extra_packed) == 1, "");
_Static_assert(sizeof(struct B032_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B032_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B032_extra_size) == 6, "");
_Static_assert(_Alignof(struct B032_extra_size) == 1, "");
_Static_assert(sizeof(B033) == 4, "");
_Static_assert(_Alignof(B033) == 4, "");
_Static_assert(sizeof(struct B033_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B033_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B033_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B033_extra_packed) == 1, "");
_Static_assert(sizeof(struct B033_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B033_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B033_extra_size) == 6, "");
_Static_assert(_Alignof(struct B033_extra_size) == 1, "");
_Static_assert(sizeof(B034) == 4, "");
_Static_assert(_Alignof(B034) == 4, "");
_Static_assert(sizeof(struct B034_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B034_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B034_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B034_extra_packed) == 1, "");
_Static_assert(sizeof(struct B034_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B034_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B034_extra_size) == 6, "");
_Static_assert(_Alignof(struct B034_extra_size) == 1, "");
_Static_assert(sizeof(B035) == 4, "");
_Static_assert(_Alignof(B035) == 4, "");
_Static_assert(sizeof(struct B035_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B035_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B035_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B035_extra_packed) == 1, "");
_Static_assert(sizeof(struct B035_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B035_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B035_extra_size) == 6, "");
_Static_assert(_Alignof(struct B035_extra_size) == 1, "");
_Static_assert(sizeof(B036) == 4, "");
_Static_assert(_Alignof(B036) == 4, "");
_Static_assert(sizeof(struct B036_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B036_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B036_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B036_extra_packed) == 1, "");
_Static_assert(sizeof(struct B036_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B036_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B036_extra_size) == 6, "");
_Static_assert(_Alignof(struct B036_extra_size) == 1, "");
_Static_assert(sizeof(B041) == 8, "");
_Static_assert(_Alignof(B041) == 8, "");
_Static_assert(sizeof(struct B041_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B041_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B041_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B041_extra_packed) == 1, "");
_Static_assert(sizeof(struct B041_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B041_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B041_extra_size) == 10, "");
_Static_assert(_Alignof(struct B041_extra_size) == 1, "");
_Static_assert(sizeof(B042) == 8, "");
_Static_assert(_Alignof(B042) == 8, "");
_Static_assert(sizeof(struct B042_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B042_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B042_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B042_extra_packed) == 1, "");
_Static_assert(sizeof(struct B042_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B042_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B042_extra_size) == 10, "");
_Static_assert(_Alignof(struct B042_extra_size) == 1, "");
_Static_assert(sizeof(B043) == 8, "");
_Static_assert(_Alignof(B043) == 8, "");
_Static_assert(sizeof(struct B043_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B043_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B043_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B043_extra_packed) == 1, "");
_Static_assert(sizeof(struct B043_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B043_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B043_extra_size) == 10, "");
_Static_assert(_Alignof(struct B043_extra_size) == 1, "");
_Static_assert(sizeof(B044) == 8, "");
_Static_assert(_Alignof(B044) == 8, "");
_Static_assert(sizeof(struct B044_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B044_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B044_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B044_extra_packed) == 1, "");
_Static_assert(sizeof(struct B044_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B044_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B044_extra_size) == 10, "");
_Static_assert(_Alignof(struct B044_extra_size) == 1, "");
_Static_assert(sizeof(B045) == 8, "");
_Static_assert(_Alignof(B045) == 8, "");
_Static_assert(sizeof(struct B045_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B045_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B045_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B045_extra_packed) == 1, "");
_Static_assert(sizeof(struct B045_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B045_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B045_extra_size) == 10, "");
_Static_assert(_Alignof(struct B045_extra_size) == 1, "");
_Static_assert(sizeof(B046) == 8, "");
_Static_assert(_Alignof(B046) == 8, "");
_Static_assert(sizeof(struct B046_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B046_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B046_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B046_extra_packed) == 1, "");
_Static_assert(sizeof(struct B046_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B046_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B046_extra_size) == 10, "");
_Static_assert(_Alignof(struct B046_extra_size) == 1, "");
_Static_assert(sizeof(B047) == 8, "");
_Static_assert(_Alignof(B047) == 8, "");
_Static_assert(sizeof(struct B047_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B047_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B047_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B047_extra_packed) == 1, "");
_Static_assert(sizeof(struct B047_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B047_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B047_extra_size) == 10, "");
_Static_assert(_Alignof(struct B047_extra_size) == 1, "");
_Static_assert(sizeof(B048) == 8, "");
_Static_assert(_Alignof(B048) == 8, "");
_Static_assert(sizeof(struct B048_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B048_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B048_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B048_extra_packed) == 1, "");
_Static_assert(sizeof(struct B048_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B048_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B048_extra_size) == 10, "");
_Static_assert(_Alignof(struct B048_extra_size) == 1, "");
_Static_assert(sizeof(B049) == 8, "");
_Static_assert(_Alignof(B049) == 8, "");
_Static_assert(sizeof(struct B049_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B049_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B049_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B049_extra_packed) == 1, "");
_Static_assert(sizeof(struct B049_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B049_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B049_extra_size) == 10, "");
_Static_assert(_Alignof(struct B049_extra_size) == 1, "");
_Static_assert(sizeof(B050) == 8, "");
_Static_assert(_Alignof(B050) == 8, "");
_Static_assert(sizeof(struct B050_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B050_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B050_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B050_extra_packed) == 1, "");
_Static_assert(sizeof(struct B050_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B050_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B050_extra_size) == 10, "");
_Static_assert(_Alignof(struct B050_extra_size) == 1, "");
_Static_assert(sizeof(B051) == 8, "");
_Static_assert(_Alignof(B051) == 8, "");
_Static_assert(sizeof(struct B051_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B051_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B051_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B051_extra_packed) == 1, "");
_Static_assert(sizeof(struct B051_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B051_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B051_extra_size) == 10, "");
_Static_assert(_Alignof(struct B051_extra_size) == 1, "");
_Static_assert(sizeof(B052) == 8, "");
_Static_assert(_Alignof(B052) == 8, "");
_Static_assert(sizeof(struct B052_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B052_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B052_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B052_extra_packed) == 1, "");
_Static_assert(sizeof(struct B052_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B052_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B052_extra_size) == 10, "");
_Static_assert(_Alignof(struct B052_extra_size) == 1, "");
_Static_assert(sizeof(B053) == 8, "");
_Static_assert(_Alignof(B053) == 8, "");
_Static_assert(sizeof(struct B053_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B053_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B053_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B053_extra_packed) == 1, "");
_Static_assert(sizeof(struct B053_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B053_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B053_extra_size) == 10, "");
_Static_assert(_Alignof(struct B053_extra_size) == 1, "");
_Static_assert(sizeof(B054) == 8, "");
_Static_assert(_Alignof(B054) == 8, "");
_Static_assert(sizeof(struct B054_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B054_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B054_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B054_extra_packed) == 1, "");
_Static_assert(sizeof(struct B054_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B054_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B054_extra_size) == 10, "");
_Static_assert(_Alignof(struct B054_extra_size) == 1, "");
_Static_assert(sizeof(B055) == 8, "");
_Static_assert(_Alignof(B055) == 8, "");
_Static_assert(sizeof(struct B055_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B055_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B055_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B055_extra_packed) == 1, "");
_Static_assert(sizeof(struct B055_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B055_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B055_extra_size) == 10, "");
_Static_assert(_Alignof(struct B055_extra_size) == 1, "");
_Static_assert(sizeof(B056) == 8, "");
_Static_assert(_Alignof(B056) == 8, "");
_Static_assert(sizeof(struct B056_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B056_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B056_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B056_extra_packed) == 1, "");
_Static_assert(sizeof(struct B056_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B056_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B056_extra_size) == 10, "");
_Static_assert(_Alignof(struct B056_extra_size) == 1, "");
_Static_assert(sizeof(B061) == 8, "");
_Static_assert(_Alignof(B061) == 8, "");
_Static_assert(sizeof(struct B061_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B061_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B061_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B061_extra_packed) == 1, "");
_Static_assert(sizeof(struct B061_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B061_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B061_extra_size) == 10, "");
_Static_assert(_Alignof(struct B061_extra_size) == 1, "");
_Static_assert(sizeof(B062) == 8, "");
_Static_assert(_Alignof(B062) == 8, "");
_Static_assert(sizeof(struct B062_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B062_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B062_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B062_extra_packed) == 1, "");
_Static_assert(sizeof(struct B062_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B062_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B062_extra_size) == 10, "");
_Static_assert(_Alignof(struct B062_extra_size) == 1, "");
_Static_assert(sizeof(B063) == 8, "");
_Static_assert(_Alignof(B063) == 8, "");
_Static_assert(sizeof(struct B063_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B063_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B063_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B063_extra_packed) == 1, "");
_Static_assert(sizeof(struct B063_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B063_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B063_extra_size) == 10, "");
_Static_assert(_Alignof(struct B063_extra_size) == 1, "");
_Static_assert(sizeof(B064) == 8, "");
_Static_assert(_Alignof(B064) == 8, "");
_Static_assert(sizeof(struct B064_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B064_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B064_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B064_extra_packed) == 1, "");
_Static_assert(sizeof(struct B064_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B064_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B064_extra_size) == 10, "");
_Static_assert(_Alignof(struct B064_extra_size) == 1, "");
_Static_assert(sizeof(B065) == 8, "");
_Static_assert(_Alignof(B065) == 8, "");
_Static_assert(sizeof(struct B065_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B065_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B065_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B065_extra_packed) == 1, "");
_Static_assert(sizeof(struct B065_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B065_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B065_extra_size) == 10, "");
_Static_assert(_Alignof(struct B065_extra_size) == 1, "");
_Static_assert(sizeof(B066) == 8, "");
_Static_assert(_Alignof(B066) == 8, "");
_Static_assert(sizeof(struct B066_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B066_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B066_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B066_extra_packed) == 1, "");
_Static_assert(sizeof(struct B066_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B066_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B066_extra_size) == 10, "");
_Static_assert(_Alignof(struct B066_extra_size) == 1, "");
_Static_assert(sizeof(B067) == 8, "");
_Static_assert(_Alignof(B067) == 8, "");
_Static_assert(sizeof(struct B067_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B067_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B067_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B067_extra_packed) == 1, "");
_Static_assert(sizeof(struct B067_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B067_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B067_extra_size) == 10, "");
_Static_assert(_Alignof(struct B067_extra_size) == 1, "");
_Static_assert(sizeof(B068) == 8, "");
_Static_assert(_Alignof(B068) == 8, "");
_Static_assert(sizeof(struct B068_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B068_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B068_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B068_extra_packed) == 1, "");
_Static_assert(sizeof(struct B068_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B068_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B068_extra_size) == 10, "");
_Static_assert(_Alignof(struct B068_extra_size) == 1, "");
_Static_assert(sizeof(B069) == 8, "");
_Static_assert(_Alignof(B069) == 8, "");
_Static_assert(sizeof(struct B069_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B069_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B069_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B069_extra_packed) == 1, "");
_Static_assert(sizeof(struct B069_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B069_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B069_extra_size) == 10, "");
_Static_assert(_Alignof(struct B069_extra_size) == 1, "");
_Static_assert(sizeof(B070) == 8, "");
_Static_assert(_Alignof(B070) == 8, "");
_Static_assert(sizeof(struct B070_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B070_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B070_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B070_extra_packed) == 1, "");
_Static_assert(sizeof(struct B070_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B070_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B070_extra_size) == 10, "");
_Static_assert(_Alignof(struct B070_extra_size) == 1, "");
_Static_assert(sizeof(B071) == 8, "");
_Static_assert(_Alignof(B071) == 8, "");
_Static_assert(sizeof(struct B071_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B071_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B071_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B071_extra_packed) == 1, "");
_Static_assert(sizeof(struct B071_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B071_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B071_extra_size) == 10, "");
_Static_assert(_Alignof(struct B071_extra_size) == 1, "");
_Static_assert(sizeof(B072) == 8, "");
_Static_assert(_Alignof(B072) == 8, "");
_Static_assert(sizeof(struct B072_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B072_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B072_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B072_extra_packed) == 1, "");
_Static_assert(sizeof(struct B072_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B072_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B072_extra_size) == 10, "");
_Static_assert(_Alignof(struct B072_extra_size) == 1, "");
_Static_assert(sizeof(B073) == 8, "");
_Static_assert(_Alignof(B073) == 8, "");
_Static_assert(sizeof(struct B073_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B073_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B073_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B073_extra_packed) == 1, "");
_Static_assert(sizeof(struct B073_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B073_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B073_extra_size) == 10, "");
_Static_assert(_Alignof(struct B073_extra_size) == 1, "");
_Static_assert(sizeof(B074) == 8, "");
_Static_assert(_Alignof(B074) == 8, "");
_Static_assert(sizeof(struct B074_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B074_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B074_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B074_extra_packed) == 1, "");
_Static_assert(sizeof(struct B074_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B074_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B074_extra_size) == 10, "");
_Static_assert(_Alignof(struct B074_extra_size) == 1, "");
_Static_assert(sizeof(B075) == 8, "");
_Static_assert(_Alignof(B075) == 8, "");
_Static_assert(sizeof(struct B075_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B075_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B075_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B075_extra_packed) == 1, "");
_Static_assert(sizeof(struct B075_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B075_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B075_extra_size) == 10, "");
_Static_assert(_Alignof(struct B075_extra_size) == 1, "");
_Static_assert(sizeof(B076) == 8, "");
_Static_assert(_Alignof(B076) == 8, "");
_Static_assert(sizeof(struct B076_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B076_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B076_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B076_extra_packed) == 1, "");
_Static_assert(sizeof(struct B076_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B076_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B076_extra_size) == 10, "");
_Static_assert(_Alignof(struct B076_extra_size) == 1, "");
_Static_assert(sizeof(B081) == 4, "");
_Static_assert(_Alignof(B081) == 4, "");
_Static_assert(sizeof(struct B081_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B081_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B081_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B081_extra_packed) == 1, "");
_Static_assert(sizeof(struct B081_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B081_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B081_extra_size) == 6, "");
_Static_assert(_Alignof(struct B081_extra_size) == 1, "");
_Static_assert(sizeof(B082) == 4, "");
_Static_assert(_Alignof(B082) == 4, "");
_Static_assert(sizeof(struct B082_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B082_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B082_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B082_extra_packed) == 1, "");
_Static_assert(sizeof(struct B082_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B082_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B082_extra_size) == 6, "");
_Static_assert(_Alignof(struct B082_extra_size) == 1, "");
_Static_assert(sizeof(B083) == 4, "");
_Static_assert(_Alignof(B083) == 4, "");
_Static_assert(sizeof(struct B083_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B083_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B083_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B083_extra_packed) == 1, "");
_Static_assert(sizeof(struct B083_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B083_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B083_extra_size) == 6, "");
_Static_assert(_Alignof(struct B083_extra_size) == 1, "");
_Static_assert(sizeof(B084) == 4, "");
_Static_assert(_Alignof(B084) == 4, "");
_Static_assert(sizeof(struct B084_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B084_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B084_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B084_extra_packed) == 1, "");
_Static_assert(sizeof(struct B084_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B084_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B084_extra_size) == 6, "");
_Static_assert(_Alignof(struct B084_extra_size) == 1, "");
_Static_assert(sizeof(B085) == 4, "");
_Static_assert(_Alignof(B085) == 4, "");
_Static_assert(sizeof(struct B085_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B085_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B085_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B085_extra_packed) == 1, "");
_Static_assert(sizeof(struct B085_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B085_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B085_extra_size) == 6, "");
_Static_assert(_Alignof(struct B085_extra_size) == 1, "");
_Static_assert(sizeof(B086) == 4, "");
_Static_assert(_Alignof(B086) == 4, "");
_Static_assert(sizeof(struct B086_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B086_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B086_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B086_extra_packed) == 1, "");
_Static_assert(sizeof(struct B086_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B086_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B086_extra_size) == 6, "");
_Static_assert(_Alignof(struct B086_extra_size) == 1, "");
_Static_assert(sizeof(B087) == 4, "");
_Static_assert(_Alignof(B087) == 4, "");
_Static_assert(sizeof(struct B087_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B087_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B087_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B087_extra_packed) == 1, "");
_Static_assert(sizeof(struct B087_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B087_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B087_extra_size) == 6, "");
_Static_assert(_Alignof(struct B087_extra_size) == 1, "");
_Static_assert(sizeof(B088) == 4, "");
_Static_assert(_Alignof(B088) == 4, "");
_Static_assert(sizeof(struct B088_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B088_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B088_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B088_extra_packed) == 1, "");
_Static_assert(sizeof(struct B088_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B088_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B088_extra_size) == 6, "");
_Static_assert(_Alignof(struct B088_extra_size) == 1, "");
_Static_assert(sizeof(B089) == 4, "");
_Static_assert(_Alignof(B089) == 4, "");
_Static_assert(sizeof(struct B089_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B089_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B089_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B089_extra_packed) == 1, "");
_Static_assert(sizeof(struct B089_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B089_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B089_extra_size) == 6, "");
_Static_assert(_Alignof(struct B089_extra_size) == 1, "");
_Static_assert(sizeof(B090) == 4, "");
_Static_assert(_Alignof(B090) == 4, "");
_Static_assert(sizeof(struct B090_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B090_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B090_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B090_extra_packed) == 1, "");
_Static_assert(sizeof(struct B090_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B090_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B090_extra_size) == 6, "");
_Static_assert(_Alignof(struct B090_extra_size) == 1, "");
_Static_assert(sizeof(B091) == 4, "");
_Static_assert(_Alignof(B091) == 4, "");
_Static_assert(sizeof(struct B091_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B091_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B091_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B091_extra_packed) == 1, "");
_Static_assert(sizeof(struct B091_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B091_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B091_extra_size) == 6, "");
_Static_assert(_Alignof(struct B091_extra_size) == 1, "");
_Static_assert(sizeof(B092) == 4, "");
_Static_assert(_Alignof(B092) == 4, "");
_Static_assert(sizeof(struct B092_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B092_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B092_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B092_extra_packed) == 1, "");
_Static_assert(sizeof(struct B092_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B092_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B092_extra_size) == 6, "");
_Static_assert(_Alignof(struct B092_extra_size) == 1, "");
_Static_assert(sizeof(B093) == 4, "");
_Static_assert(_Alignof(B093) == 4, "");
_Static_assert(sizeof(struct B093_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B093_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B093_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B093_extra_packed) == 1, "");
_Static_assert(sizeof(struct B093_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B093_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B093_extra_size) == 6, "");
_Static_assert(_Alignof(struct B093_extra_size) == 1, "");
_Static_assert(sizeof(B094) == 4, "");
_Static_assert(_Alignof(B094) == 4, "");
_Static_assert(sizeof(struct B094_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B094_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B094_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B094_extra_packed) == 1, "");
_Static_assert(sizeof(struct B094_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B094_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B094_extra_size) == 6, "");
_Static_assert(_Alignof(struct B094_extra_size) == 1, "");
_Static_assert(sizeof(B095) == 4, "");
_Static_assert(_Alignof(B095) == 4, "");
_Static_assert(sizeof(struct B095_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B095_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B095_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B095_extra_packed) == 1, "");
_Static_assert(sizeof(struct B095_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B095_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B095_extra_size) == 6, "");
_Static_assert(_Alignof(struct B095_extra_size) == 1, "");
_Static_assert(sizeof(B096) == 4, "");
_Static_assert(_Alignof(B096) == 4, "");
_Static_assert(sizeof(struct B096_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B096_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B096_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B096_extra_packed) == 1, "");
_Static_assert(sizeof(struct B096_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B096_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B096_extra_size) == 6, "");
_Static_assert(_Alignof(struct B096_extra_size) == 1, "");
_Static_assert(sizeof(B101) == 4, "");
_Static_assert(_Alignof(B101) == 4, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 6, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
_Static_assert(sizeof(B102) == 4, "");
_Static_assert(_Alignof(B102) == 4, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 6, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 4, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 4, "");
_Static_assert(_Alignof(B105) == 4, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 6, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
_Static_assert(sizeof(B106) == 4, "");
_Static_assert(_Alignof(B106) == 4, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 6, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
_Static_assert(sizeof(B107) == 4, "");
_Static_assert(_Alignof(B107) == 4, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 6, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 4, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
_Static_assert(sizeof(B109) == 4, "");
_Static_assert(_Alignof(B109) == 4, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 6, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 4, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 4, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 4, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 4, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 4, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 4, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
_Static_assert(sizeof(B121) == 8, "");
_Static_assert(_Alignof(B121) == 8, "");
_Static_assert(sizeof(struct B121_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B121_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B121_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B121_extra_packed) == 1, "");
_Static_assert(sizeof(struct B121_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B121_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B121_extra_size) == 10, "");
_Static_assert(_Alignof(struct B121_extra_size) == 1, "");
_Static_assert(sizeof(B122) == 8, "");
_Static_assert(_Alignof(B122) == 8, "");
_Static_assert(sizeof(struct B122_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B122_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B122_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B122_extra_packed) == 1, "");
_Static_assert(sizeof(struct B122_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B122_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B122_extra_size) == 10, "");
_Static_assert(_Alignof(struct B122_extra_size) == 1, "");
_Static_assert(sizeof(B123) == 8, "");
_Static_assert(_Alignof(B123) == 8, "");
_Static_assert(sizeof(struct B123_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B123_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B123_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B123_extra_packed) == 1, "");
_Static_assert(sizeof(struct B123_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B123_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B123_extra_size) == 10, "");
_Static_assert(_Alignof(struct B123_extra_size) == 1, "");
_Static_assert(sizeof(B124) == 8, "");
_Static_assert(_Alignof(B124) == 8, "");
_Static_assert(sizeof(struct B124_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B124_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B124_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B124_extra_packed) == 1, "");
_Static_assert(sizeof(struct B124_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B124_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B124_extra_size) == 10, "");
_Static_assert(_Alignof(struct B124_extra_size) == 1, "");
_Static_assert(sizeof(B125) == 8, "");
_Static_assert(_Alignof(B125) == 8, "");
_Static_assert(sizeof(struct B125_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B125_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B125_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B125_extra_packed) == 1, "");
_Static_assert(sizeof(struct B125_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B125_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B125_extra_size) == 10, "");
_Static_assert(_Alignof(struct B125_extra_size) == 1, "");
_Static_assert(sizeof(B126) == 8, "");
_Static_assert(_Alignof(B126) == 8, "");
_Static_assert(sizeof(struct B126_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B126_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B126_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B126_extra_packed) == 1, "");
_Static_assert(sizeof(struct B126_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B126_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B126_extra_size) == 10, "");
_Static_assert(_Alignof(struct B126_extra_size) == 1, "");
_Static_assert(sizeof(B127) == 8, "");
_Static_assert(_Alignof(B127) == 8, "");
_Static_assert(sizeof(struct B127_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B127_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B127_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B127_extra_packed) == 1, "");
_Static_assert(sizeof(struct B127_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B127_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B127_extra_size) == 10, "");
_Static_assert(_Alignof(struct B127_extra_size) == 1, "");
_Static_assert(sizeof(B128) == 8, "");
_Static_assert(_Alignof(B128) == 8, "");
_Static_assert(sizeof(struct B128_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B128_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B128_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B128_extra_packed) == 1, "");
_Static_assert(sizeof(struct B128_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B128_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B128_extra_size) == 10, "");
_Static_assert(_Alignof(struct B128_extra_size) == 1, "");
_Static_assert(sizeof(B129) == 8, "");
_Static_assert(_Alignof(B129) == 8, "");
_Static_assert(sizeof(struct B129_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B129_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B129_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B129_extra_packed) == 1, "");
_Static_assert(sizeof(struct B129_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B129_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B129_extra_size) == 10, "");
_Static_assert(_Alignof(struct B129_extra_size) == 1, "");
_Static_assert(sizeof(B130) == 8, "");
_Static_assert(_Alignof(B130) == 8, "");
_Static_assert(sizeof(struct B130_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B130_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B130_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B130_extra_packed) == 1, "");
_Static_assert(sizeof(struct B130_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B130_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B130_extra_size) == 10, "");
_Static_assert(_Alignof(struct B130_extra_size) == 1, "");
_Static_assert(sizeof(B131) == 8, "");
_Static_assert(_Alignof(B131) == 8, "");
_Static_assert(sizeof(struct B131_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B131_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B131_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B131_extra_packed) == 1, "");
_Static_assert(sizeof(struct B131_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B131_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B131_extra_size) == 10, "");
_Static_assert(_Alignof(struct B131_extra_size) == 1, "");
_Static_assert(sizeof(B132) == 8, "");
_Static_assert(_Alignof(B132) == 8, "");
_Static_assert(sizeof(struct B132_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B132_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B132_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B132_extra_packed) == 1, "");
_Static_assert(sizeof(struct B132_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B132_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B132_extra_size) == 10, "");
_Static_assert(_Alignof(struct B132_extra_size) == 1, "");
_Static_assert(sizeof(B133) == 8, "");
_Static_assert(_Alignof(B133) == 8, "");
_Static_assert(sizeof(struct B133_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B133_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B133_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B133_extra_packed) == 1, "");
_Static_assert(sizeof(struct B133_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B133_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B133_extra_size) == 10, "");
_Static_assert(_Alignof(struct B133_extra_size) == 1, "");
_Static_assert(sizeof(B134) == 8, "");
_Static_assert(_Alignof(B134) == 8, "");
_Static_assert(sizeof(struct B134_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B134_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B134_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B134_extra_packed) == 1, "");
_Static_assert(sizeof(struct B134_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B134_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B134_extra_size) == 10, "");
_Static_assert(_Alignof(struct B134_extra_size) == 1, "");
_Static_assert(sizeof(B135) == 8, "");
_Static_assert(_Alignof(B135) == 8, "");
_Static_assert(sizeof(struct B135_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B135_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B135_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B135_extra_packed) == 1, "");
_Static_assert(sizeof(struct B135_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B135_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B135_extra_size) == 10, "");
_Static_assert(_Alignof(struct B135_extra_size) == 1, "");
_Static_assert(sizeof(B136) == 8, "");
_Static_assert(_Alignof(B136) == 8, "");
_Static_assert(sizeof(struct B136_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B136_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B136_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B136_extra_packed) == 1, "");
_Static_assert(sizeof(struct B136_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B136_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B136_extra_size) == 10, "");
_Static_assert(_Alignof(struct B136_extra_size) == 1, "");
_Static_assert(sizeof(B141) == 8, "");
_Static_assert(_Alignof(B141) == 8, "");
_Static_assert(sizeof(struct B141_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B141_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B141_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B141_extra_packed) == 1, "");
_Static_assert(sizeof(struct B141_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B141_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B141_extra_size) == 10, "");
_Static_assert(_Alignof(struct B141_extra_size) == 1, "");
_Static_assert(sizeof(B142) == 8, "");
_Static_assert(_Alignof(B142) == 8, "");
_Static_assert(sizeof(struct B142_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B142_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B142_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B142_extra_packed) == 1, "");
_Static_assert(sizeof(struct B142_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B142_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B142_extra_size) == 10, "");
_Static_assert(_Alignof(struct B142_extra_size) == 1, "");
_Static_assert(sizeof(B143) == 8, "");
_Static_assert(_Alignof(B143) == 8, "");
_Static_assert(sizeof(struct B143_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B143_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B143_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B143_extra_packed) == 1, "");
_Static_assert(sizeof(struct B143_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B143_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B143_extra_size) == 10, "");
_Static_assert(_Alignof(struct B143_extra_size) == 1, "");
_Static_assert(sizeof(B144) == 8, "");
_Static_assert(_Alignof(B144) == 8, "");
_Static_assert(sizeof(struct B144_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B144_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B144_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B144_extra_packed) == 1, "");
_Static_assert(sizeof(struct B144_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B144_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B144_extra_size) == 10, "");
_Static_assert(_Alignof(struct B144_extra_size) == 1, "");
_Static_assert(sizeof(B145) == 8, "");
_Static_assert(_Alignof(B145) == 8, "");
_Static_assert(sizeof(struct B145_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B145_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B145_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B145_extra_packed) == 1, "");
_Static_assert(sizeof(struct B145_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B145_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B145_extra_size) == 10, "");
_Static_assert(_Alignof(struct B145_extra_size) == 1, "");
_Static_assert(sizeof(B146) == 8, "");
_Static_assert(_Alignof(B146) == 8, "");
_Static_assert(sizeof(struct B146_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B146_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B146_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B146_extra_packed) == 1, "");
_Static_assert(sizeof(struct B146_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B146_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B146_extra_size) == 10, "");
_Static_assert(_Alignof(struct B146_extra_size) == 1, "");
_Static_assert(sizeof(B147) == 8, "");
_Static_assert(_Alignof(B147) == 8, "");
_Static_assert(sizeof(struct B147_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B147_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B147_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B147_extra_packed) == 1, "");
_Static_assert(sizeof(struct B147_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B147_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B147_extra_size) == 10, "");
_Static_assert(_Alignof(struct B147_extra_size) == 1, "");
_Static_assert(sizeof(B148) == 8, "");
_Static_assert(_Alignof(B148) == 8, "");
_Static_assert(sizeof(struct B148_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B148_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B148_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B148_extra_packed) == 1, "");
_Static_assert(sizeof(struct B148_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B148_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B148_extra_size) == 10, "");
_Static_assert(_Alignof(struct B148_extra_size) == 1, "");
_Static_assert(sizeof(B149) == 8, "");
_Static_assert(_Alignof(B149) == 8, "");
_Static_assert(sizeof(struct B149_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B149_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B149_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B149_extra_packed) == 1, "");
_Static_assert(sizeof(struct B149_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B149_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B149_extra_size) == 10, "");
_Static_assert(_Alignof(struct B149_extra_size) == 1, "");
_Static_assert(sizeof(B150) == 8, "");
_Static_assert(_Alignof(B150) == 8, "");
_Static_assert(sizeof(struct B150_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B150_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B150_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B150_extra_packed) == 1, "");
_Static_assert(sizeof(struct B150_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B150_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B150_extra_size) == 10, "");
_Static_assert(_Alignof(struct B150_extra_size) == 1, "");
_Static_assert(sizeof(B151) == 8, "");
_Static_assert(_Alignof(B151) == 8, "");
_Static_assert(sizeof(struct B151_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B151_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B151_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B151_extra_packed) == 1, "");
_Static_assert(sizeof(struct B151_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B151_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B151_extra_size) == 10, "");
_Static_assert(_Alignof(struct B151_extra_size) == 1, "");
_Static_assert(sizeof(B152) == 8, "");
_Static_assert(_Alignof(B152) == 8, "");
_Static_assert(sizeof(struct B152_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B152_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B152_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B152_extra_packed) == 1, "");
_Static_assert(sizeof(struct B152_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B152_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B152_extra_size) == 10, "");
_Static_assert(_Alignof(struct B152_extra_size) == 1, "");
_Static_assert(sizeof(B153) == 8, "");
_Static_assert(_Alignof(B153) == 8, "");
_Static_assert(sizeof(struct B153_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B153_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B153_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B153_extra_packed) == 1, "");
_Static_assert(sizeof(struct B153_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B153_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B153_extra_size) == 10, "");
_Static_assert(_Alignof(struct B153_extra_size) == 1, "");
_Static_assert(sizeof(B154) == 8, "");
_Static_assert(_Alignof(B154) == 8, "");
_Static_assert(sizeof(struct B154_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B154_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B154_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B154_extra_packed) == 1, "");
_Static_assert(sizeof(struct B154_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B154_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B154_extra_size) == 10, "");
_Static_assert(_Alignof(struct B154_extra_size) == 1, "");
_Static_assert(sizeof(B155) == 8, "");
_Static_assert(_Alignof(B155) == 8, "");
_Static_assert(sizeof(struct B155_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B155_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B155_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B155_extra_packed) == 1, "");
_Static_assert(sizeof(struct B155_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B155_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B155_extra_size) == 10, "");
_Static_assert(_Alignof(struct B155_extra_size) == 1, "");
_Static_assert(sizeof(B156) == 8, "");
_Static_assert(_Alignof(B156) == 8, "");
_Static_assert(sizeof(struct B156_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B156_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B156_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B156_extra_packed) == 1, "");
_Static_assert(sizeof(struct B156_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B156_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B156_extra_size) == 10, "");
_Static_assert(_Alignof(struct B156_extra_size) == 1, "");
// MAPPING|TWO|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(TWO)
_Static_assert(sizeof(A000) == 1, "");
_Static_assert(_Alignof(A000) == 1, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 3, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
_Static_assert(sizeof(A001) == 1, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 3, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
_Static_assert(sizeof(A002) == 1, "");
_Static_assert(_Alignof(A002) == 1, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 3, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
_Static_assert(sizeof(A003) == 1, "");
_Static_assert(_Alignof(A003) == 1, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 3, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
_Static_assert(sizeof(A004) == 1, "");
_Static_assert(_Alignof(A004) == 1, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 3, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 1, "");
_Static_assert(_Alignof(A005) == 1, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 3, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
_Static_assert(sizeof(A006) == 1, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 3, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
_Static_assert(sizeof(A007) == 1, "");
_Static_assert(_Alignof(A007) == 1, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 3, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
_Static_assert(sizeof(A008) == 1, "");
_Static_assert(_Alignof(A008) == 1, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 3, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
_Static_assert(sizeof(A009) == 2, "");
_Static_assert(_Alignof(A009) == 2, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A009_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 4, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
_Static_assert(sizeof(A010) == 2, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 4, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
_Static_assert(sizeof(A011) == 2, "");
_Static_assert(_Alignof(A011) == 2, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 4, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
_Static_assert(sizeof(A012) == 2, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 4, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
_Static_assert(sizeof(A013) == 2, "");
_Static_assert(_Alignof(A013) == 2, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A013_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 4, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
_Static_assert(sizeof(A014) == 2, "");
_Static_assert(_Alignof(A014) == 2, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A014_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 4, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
_Static_assert(sizeof(A015) == 2, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 4, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
_Static_assert(sizeof(A016) == 2, "");
_Static_assert(_Alignof(A016) == 2, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 4, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
_Static_assert(sizeof(A021) == 4, "");
_Static_assert(_Alignof(A021) == 4, "");
_Static_assert(sizeof(struct A021_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A021_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A021_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A021_extra_packed) == 1, "");
_Static_assert(sizeof(struct A021_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A021_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A021_extra_size) == 6, "");
_Static_assert(_Alignof(struct A021_extra_size) == 1, "");
_Static_assert(sizeof(A022) == 4, "");
_Static_assert(_Alignof(A022) == 4, "");
_Static_assert(sizeof(struct A022_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A022_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A022_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A022_extra_packed) == 1, "");
_Static_assert(sizeof(struct A022_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A022_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A022_extra_size) == 6, "");
_Static_assert(_Alignof(struct A022_extra_size) == 1, "");
_Static_assert(sizeof(A023) == 4, "");
_Static_assert(_Alignof(A023) == 4, "");
_Static_assert(sizeof(struct A023_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A023_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A023_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A023_extra_packed) == 1, "");
_Static_assert(sizeof(struct A023_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A023_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A023_extra_size) == 6, "");
_Static_assert(_Alignof(struct A023_extra_size) == 1, "");
_Static_assert(sizeof(A024) == 4, "");
_Static_assert(_Alignof(A024) == 4, "");
_Static_assert(sizeof(struct A024_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A024_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A024_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A024_extra_packed) == 1, "");
_Static_assert(sizeof(struct A024_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A024_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A024_extra_size) == 6, "");
_Static_assert(_Alignof(struct A024_extra_size) == 1, "");
_Static_assert(sizeof(A025) == 4, "");
_Static_assert(_Alignof(A025) == 4, "");
_Static_assert(sizeof(struct A025_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A025_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A025_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A025_extra_packed) == 1, "");
_Static_assert(sizeof(struct A025_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A025_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A025_extra_size) == 6, "");
_Static_assert(_Alignof(struct A025_extra_size) == 1, "");
_Static_assert(sizeof(A026) == 4, "");
_Static_assert(_Alignof(A026) == 4, "");
_Static_assert(sizeof(struct A026_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A026_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A026_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A026_extra_packed) == 1, "");
_Static_assert(sizeof(struct A026_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A026_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A026_extra_size) == 6, "");
_Static_assert(_Alignof(struct A026_extra_size) == 1, "");
_Static_assert(sizeof(A027) == 4, "");
_Static_assert(_Alignof(A027) == 4, "");
_Static_assert(sizeof(struct A027_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A027_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A027_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A027_extra_packed) == 1, "");
_Static_assert(sizeof(struct A027_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A027_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A027_extra_size) == 6, "");
_Static_assert(_Alignof(struct A027_extra_size) == 1, "");
_Static_assert(sizeof(A028) == 4, "");
_Static_assert(_Alignof(A028) == 4, "");
_Static_assert(sizeof(struct A028_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A028_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A028_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A028_extra_packed) == 1, "");
_Static_assert(sizeof(struct A028_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A028_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A028_extra_size) == 6, "");
_Static_assert(_Alignof(struct A028_extra_size) == 1, "");
_Static_assert(sizeof(A029) == 4, "");
_Static_assert(_Alignof(A029) == 4, "");
_Static_assert(sizeof(struct A029_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A029_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A029_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A029_extra_packed) == 1, "");
_Static_assert(sizeof(struct A029_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A029_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A029_extra_size) == 6, "");
_Static_assert(_Alignof(struct A029_extra_size) == 1, "");
_Static_assert(sizeof(A030) == 4, "");
_Static_assert(_Alignof(A030) == 4, "");
_Static_assert(sizeof(struct A030_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A030_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A030_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A030_extra_packed) == 1, "");
_Static_assert(sizeof(struct A030_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A030_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A030_extra_size) == 6, "");
_Static_assert(_Alignof(struct A030_extra_size) == 1, "");
_Static_assert(sizeof(A031) == 4, "");
_Static_assert(_Alignof(A031) == 4, "");
_Static_assert(sizeof(struct A031_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A031_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A031_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A031_extra_packed) == 1, "");
_Static_assert(sizeof(struct A031_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A031_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A031_extra_size) == 6, "");
_Static_assert(_Alignof(struct A031_extra_size) == 1, "");
_Static_assert(sizeof(A032) == 4, "");
_Static_assert(_Alignof(A032) == 4, "");
_Static_assert(sizeof(struct A032_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A032_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A032_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A032_extra_packed) == 1, "");
_Static_assert(sizeof(struct A032_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A032_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A032_extra_size) == 6, "");
_Static_assert(_Alignof(struct A032_extra_size) == 1, "");
_Static_assert(sizeof(A033) == 4, "");
_Static_assert(_Alignof(A033) == 4, "");
_Static_assert(sizeof(struct A033_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A033_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A033_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A033_extra_packed) == 1, "");
_Static_assert(sizeof(struct A033_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A033_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A033_extra_size) == 6, "");
_Static_assert(_Alignof(struct A033_extra_size) == 1, "");
_Static_assert(sizeof(A034) == 4, "");
_Static_assert(_Alignof(A034) == 4, "");
_Static_assert(sizeof(struct A034_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A034_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A034_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A034_extra_packed) == 1, "");
_Static_assert(sizeof(struct A034_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A034_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A034_extra_size) == 6, "");
_Static_assert(_Alignof(struct A034_extra_size) == 1, "");
_Static_assert(sizeof(A035) == 4, "");
_Static_assert(_Alignof(A035) == 4, "");
_Static_assert(sizeof(struct A035_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A035_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A035_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A035_extra_packed) == 1, "");
_Static_assert(sizeof(struct A035_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A035_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A035_extra_size) == 6, "");
_Static_assert(_Alignof(struct A035_extra_size) == 1, "");
_Static_assert(sizeof(A036) == 4, "");
_Static_assert(_Alignof(A036) == 4, "");
_Static_assert(sizeof(struct A036_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A036_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A036_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A036_extra_packed) == 1, "");
_Static_assert(sizeof(struct A036_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A036_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A036_extra_size) == 6, "");
_Static_assert(_Alignof(struct A036_extra_size) == 1, "");
_Static_assert(sizeof(A041) == 8, "");
_Static_assert(_Alignof(A041) == 4, "");
_Static_assert(sizeof(struct A041_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A041_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A041_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A041_extra_packed) == 1, "");
_Static_assert(sizeof(struct A041_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A041_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A041_extra_size) == 10, "");
_Static_assert(_Alignof(struct A041_extra_size) == 1, "");
_Static_assert(sizeof(A042) == 8, "");
_Static_assert(_Alignof(A042) == 4, "");
_Static_assert(sizeof(struct A042_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A042_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A042_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A042_extra_packed) == 1, "");
_Static_assert(sizeof(struct A042_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A042_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A042_extra_size) == 10, "");
_Static_assert(_Alignof(struct A042_extra_size) == 1, "");
_Static_assert(sizeof(A043) == 8, "");
_Static_assert(_Alignof(A043) == 4, "");
_Static_assert(sizeof(struct A043_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A043_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A043_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A043_extra_packed) == 1, "");
_Static_assert(sizeof(struct A043_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A043_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A043_extra_size) == 10, "");
_Static_assert(_Alignof(struct A043_extra_size) == 1, "");
_Static_assert(sizeof(A044) == 8, "");
_Static_assert(_Alignof(A044) == 4, "");
_Static_assert(sizeof(struct A044_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A044_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A044_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A044_extra_packed) == 1, "");
_Static_assert(sizeof(struct A044_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A044_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A044_extra_size) == 10, "");
_Static_assert(_Alignof(struct A044_extra_size) == 1, "");
_Static_assert(sizeof(A045) == 8, "");
_Static_assert(_Alignof(A045) == 4, "");
_Static_assert(sizeof(struct A045_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A045_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A045_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A045_extra_packed) == 1, "");
_Static_assert(sizeof(struct A045_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A045_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A045_extra_size) == 10, "");
_Static_assert(_Alignof(struct A045_extra_size) == 1, "");
_Static_assert(sizeof(A046) == 8, "");
_Static_assert(_Alignof(A046) == 4, "");
_Static_assert(sizeof(struct A046_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A046_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A046_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A046_extra_packed) == 1, "");
_Static_assert(sizeof(struct A046_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A046_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A046_extra_size) == 10, "");
_Static_assert(_Alignof(struct A046_extra_size) == 1, "");
_Static_assert(sizeof(A047) == 8, "");
_Static_assert(_Alignof(A047) == 4, "");
_Static_assert(sizeof(struct A047_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A047_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A047_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A047_extra_packed) == 1, "");
_Static_assert(sizeof(struct A047_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A047_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A047_extra_size) == 10, "");
_Static_assert(_Alignof(struct A047_extra_size) == 1, "");
_Static_assert(sizeof(A048) == 8, "");
_Static_assert(_Alignof(A048) == 4, "");
_Static_assert(sizeof(struct A048_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A048_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A048_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A048_extra_packed) == 1, "");
_Static_assert(sizeof(struct A048_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A048_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A048_extra_size) == 10, "");
_Static_assert(_Alignof(struct A048_extra_size) == 1, "");
_Static_assert(sizeof(A049) == 8, "");
_Static_assert(_Alignof(A049) == 4, "");
_Static_assert(sizeof(struct A049_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A049_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A049_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A049_extra_packed) == 1, "");
_Static_assert(sizeof(struct A049_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A049_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A049_extra_size) == 10, "");
_Static_assert(_Alignof(struct A049_extra_size) == 1, "");
_Static_assert(sizeof(A050) == 8, "");
_Static_assert(_Alignof(A050) == 4, "");
_Static_assert(sizeof(struct A050_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A050_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A050_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A050_extra_packed) == 1, "");
_Static_assert(sizeof(struct A050_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A050_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A050_extra_size) == 10, "");
_Static_assert(_Alignof(struct A050_extra_size) == 1, "");
_Static_assert(sizeof(A051) == 8, "");
_Static_assert(_Alignof(A051) == 4, "");
_Static_assert(sizeof(struct A051_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A051_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A051_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A051_extra_packed) == 1, "");
_Static_assert(sizeof(struct A051_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A051_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A051_extra_size) == 10, "");
_Static_assert(_Alignof(struct A051_extra_size) == 1, "");
_Static_assert(sizeof(A052) == 8, "");
_Static_assert(_Alignof(A052) == 4, "");
_Static_assert(sizeof(struct A052_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A052_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A052_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A052_extra_packed) == 1, "");
_Static_assert(sizeof(struct A052_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A052_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A052_extra_size) == 10, "");
_Static_assert(_Alignof(struct A052_extra_size) == 1, "");
_Static_assert(sizeof(A053) == 8, "");
_Static_assert(_Alignof(A053) == 4, "");
_Static_assert(sizeof(struct A053_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A053_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A053_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A053_extra_packed) == 1, "");
_Static_assert(sizeof(struct A053_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A053_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A053_extra_size) == 10, "");
_Static_assert(_Alignof(struct A053_extra_size) == 1, "");
_Static_assert(sizeof(A054) == 8, "");
_Static_assert(_Alignof(A054) == 4, "");
_Static_assert(sizeof(struct A054_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A054_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A054_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A054_extra_packed) == 1, "");
_Static_assert(sizeof(struct A054_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A054_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A054_extra_size) == 10, "");
_Static_assert(_Alignof(struct A054_extra_size) == 1, "");
_Static_assert(sizeof(A055) == 8, "");
_Static_assert(_Alignof(A055) == 4, "");
_Static_assert(sizeof(struct A055_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A055_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A055_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A055_extra_packed) == 1, "");
_Static_assert(sizeof(struct A055_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A055_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A055_extra_size) == 10, "");
_Static_assert(_Alignof(struct A055_extra_size) == 1, "");
_Static_assert(sizeof(A056) == 8, "");
_Static_assert(_Alignof(A056) == 4, "");
_Static_assert(sizeof(struct A056_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A056_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A056_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A056_extra_packed) == 1, "");
_Static_assert(sizeof(struct A056_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A056_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A056_extra_size) == 10, "");
_Static_assert(_Alignof(struct A056_extra_size) == 1, "");
_Static_assert(sizeof(A061) == 8, "");
_Static_assert(_Alignof(A061) == 4, "");
_Static_assert(sizeof(struct A061_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A061_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A061_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A061_extra_packed) == 1, "");
_Static_assert(sizeof(struct A061_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A061_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A061_extra_size) == 10, "");
_Static_assert(_Alignof(struct A061_extra_size) == 1, "");
_Static_assert(sizeof(A062) == 8, "");
_Static_assert(_Alignof(A062) == 4, "");
_Static_assert(sizeof(struct A062_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A062_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A062_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A062_extra_packed) == 1, "");
_Static_assert(sizeof(struct A062_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A062_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A062_extra_size) == 10, "");
_Static_assert(_Alignof(struct A062_extra_size) == 1, "");
_Static_assert(sizeof(A063) == 8, "");
_Static_assert(_Alignof(A063) == 4, "");
_Static_assert(sizeof(struct A063_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A063_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A063_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A063_extra_packed) == 1, "");
_Static_assert(sizeof(struct A063_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A063_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A063_extra_size) == 10, "");
_Static_assert(_Alignof(struct A063_extra_size) == 1, "");
_Static_assert(sizeof(A064) == 8, "");
_Static_assert(_Alignof(A064) == 4, "");
_Static_assert(sizeof(struct A064_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A064_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A064_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A064_extra_packed) == 1, "");
_Static_assert(sizeof(struct A064_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A064_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A064_extra_size) == 10, "");
_Static_assert(_Alignof(struct A064_extra_size) == 1, "");
_Static_assert(sizeof(A065) == 8, "");
_Static_assert(_Alignof(A065) == 4, "");
_Static_assert(sizeof(struct A065_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A065_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A065_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A065_extra_packed) == 1, "");
_Static_assert(sizeof(struct A065_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A065_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A065_extra_size) == 10, "");
_Static_assert(_Alignof(struct A065_extra_size) == 1, "");
_Static_assert(sizeof(A066) == 8, "");
_Static_assert(_Alignof(A066) == 4, "");
_Static_assert(sizeof(struct A066_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A066_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A066_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A066_extra_packed) == 1, "");
_Static_assert(sizeof(struct A066_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A066_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A066_extra_size) == 10, "");
_Static_assert(_Alignof(struct A066_extra_size) == 1, "");
_Static_assert(sizeof(A067) == 8, "");
_Static_assert(_Alignof(A067) == 4, "");
_Static_assert(sizeof(struct A067_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A067_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A067_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A067_extra_packed) == 1, "");
_Static_assert(sizeof(struct A067_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A067_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A067_extra_size) == 10, "");
_Static_assert(_Alignof(struct A067_extra_size) == 1, "");
_Static_assert(sizeof(A068) == 8, "");
_Static_assert(_Alignof(A068) == 4, "");
_Static_assert(sizeof(struct A068_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A068_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A068_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A068_extra_packed) == 1, "");
_Static_assert(sizeof(struct A068_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A068_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A068_extra_size) == 10, "");
_Static_assert(_Alignof(struct A068_extra_size) == 1, "");
_Static_assert(sizeof(A069) == 8, "");
_Static_assert(_Alignof(A069) == 4, "");
_Static_assert(sizeof(struct A069_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A069_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A069_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A069_extra_packed) == 1, "");
_Static_assert(sizeof(struct A069_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A069_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A069_extra_size) == 10, "");
_Static_assert(_Alignof(struct A069_extra_size) == 1, "");
_Static_assert(sizeof(A070) == 8, "");
_Static_assert(_Alignof(A070) == 4, "");
_Static_assert(sizeof(struct A070_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A070_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A070_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A070_extra_packed) == 1, "");
_Static_assert(sizeof(struct A070_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A070_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A070_extra_size) == 10, "");
_Static_assert(_Alignof(struct A070_extra_size) == 1, "");
_Static_assert(sizeof(A071) == 8, "");
_Static_assert(_Alignof(A071) == 4, "");
_Static_assert(sizeof(struct A071_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A071_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A071_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A071_extra_packed) == 1, "");
_Static_assert(sizeof(struct A071_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A071_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A071_extra_size) == 10, "");
_Static_assert(_Alignof(struct A071_extra_size) == 1, "");
_Static_assert(sizeof(A072) == 8, "");
_Static_assert(_Alignof(A072) == 4, "");
_Static_assert(sizeof(struct A072_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A072_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A072_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A072_extra_packed) == 1, "");
_Static_assert(sizeof(struct A072_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A072_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A072_extra_size) == 10, "");
_Static_assert(_Alignof(struct A072_extra_size) == 1, "");
_Static_assert(sizeof(A073) == 8, "");
_Static_assert(_Alignof(A073) == 4, "");
_Static_assert(sizeof(struct A073_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A073_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A073_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A073_extra_packed) == 1, "");
_Static_assert(sizeof(struct A073_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A073_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A073_extra_size) == 10, "");
_Static_assert(_Alignof(struct A073_extra_size) == 1, "");
_Static_assert(sizeof(A074) == 8, "");
_Static_assert(_Alignof(A074) == 4, "");
_Static_assert(sizeof(struct A074_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A074_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A074_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A074_extra_packed) == 1, "");
_Static_assert(sizeof(struct A074_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A074_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A074_extra_size) == 10, "");
_Static_assert(_Alignof(struct A074_extra_size) == 1, "");
_Static_assert(sizeof(A075) == 8, "");
_Static_assert(_Alignof(A075) == 4, "");
_Static_assert(sizeof(struct A075_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A075_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A075_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A075_extra_packed) == 1, "");
_Static_assert(sizeof(struct A075_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A075_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A075_extra_size) == 10, "");
_Static_assert(_Alignof(struct A075_extra_size) == 1, "");
_Static_assert(sizeof(A076) == 8, "");
_Static_assert(_Alignof(A076) == 4, "");
_Static_assert(sizeof(struct A076_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A076_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A076_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A076_extra_packed) == 1, "");
_Static_assert(sizeof(struct A076_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A076_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A076_extra_size) == 10, "");
_Static_assert(_Alignof(struct A076_extra_size) == 1, "");
_Static_assert(sizeof(A081) == 1, "");
_Static_assert(_Alignof(A081) == 1, "");
_Static_assert(sizeof(struct A081_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A081_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A081_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A081_extra_packed) == 1, "");
_Static_assert(sizeof(struct A081_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A081_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A081_extra_size) == 3, "");
_Static_assert(_Alignof(struct A081_extra_size) == 1, "");
_Static_assert(sizeof(A082) == 1, "");
_Static_assert(_Alignof(A082) == 1, "");
_Static_assert(sizeof(struct A082_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A082_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A082_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A082_extra_packed) == 1, "");
_Static_assert(sizeof(struct A082_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A082_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A082_extra_size) == 3, "");
_Static_assert(_Alignof(struct A082_extra_size) == 1, "");
_Static_assert(sizeof(A083) == 1, "");
_Static_assert(_Alignof(A083) == 1, "");
_Static_assert(sizeof(struct A083_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A083_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A083_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A083_extra_packed) == 1, "");
_Static_assert(sizeof(struct A083_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A083_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A083_extra_size) == 3, "");
_Static_assert(_Alignof(struct A083_extra_size) == 1, "");
_Static_assert(sizeof(A084) == 1, "");
_Static_assert(_Alignof(A084) == 1, "");
_Static_assert(sizeof(struct A084_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A084_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A084_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A084_extra_packed) == 1, "");
_Static_assert(sizeof(struct A084_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A084_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A084_extra_size) == 3, "");
_Static_assert(_Alignof(struct A084_extra_size) == 1, "");
_Static_assert(sizeof(A085) == 1, "");
_Static_assert(_Alignof(A085) == 1, "");
_Static_assert(sizeof(struct A085_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A085_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A085_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A085_extra_packed) == 1, "");
_Static_assert(sizeof(struct A085_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A085_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A085_extra_size) == 3, "");
_Static_assert(_Alignof(struct A085_extra_size) == 1, "");
_Static_assert(sizeof(A086) == 1, "");
_Static_assert(_Alignof(A086) == 1, "");
_Static_assert(sizeof(struct A086_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A086_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A086_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A086_extra_packed) == 1, "");
_Static_assert(sizeof(struct A086_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A086_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A086_extra_size) == 3, "");
_Static_assert(_Alignof(struct A086_extra_size) == 1, "");
_Static_assert(sizeof(A087) == 1, "");
_Static_assert(_Alignof(A087) == 1, "");
_Static_assert(sizeof(struct A087_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A087_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A087_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A087_extra_packed) == 1, "");
_Static_assert(sizeof(struct A087_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A087_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A087_extra_size) == 3, "");
_Static_assert(_Alignof(struct A087_extra_size) == 1, "");
_Static_assert(sizeof(A088) == 1, "");
_Static_assert(_Alignof(A088) == 1, "");
_Static_assert(sizeof(struct A088_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A088_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A088_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A088_extra_packed) == 1, "");
_Static_assert(sizeof(struct A088_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A088_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A088_extra_size) == 3, "");
_Static_assert(_Alignof(struct A088_extra_size) == 1, "");
_Static_assert(sizeof(A089) == 2, "");
_Static_assert(_Alignof(A089) == 2, "");
_Static_assert(sizeof(struct A089_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A089_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A089_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A089_extra_packed) == 1, "");
_Static_assert(sizeof(struct A089_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A089_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A089_extra_size) == 4, "");
_Static_assert(_Alignof(struct A089_extra_size) == 1, "");
_Static_assert(sizeof(A090) == 2, "");
_Static_assert(_Alignof(A090) == 2, "");
_Static_assert(sizeof(struct A090_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A090_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A090_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A090_extra_packed) == 1, "");
_Static_assert(sizeof(struct A090_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A090_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A090_extra_size) == 4, "");
_Static_assert(_Alignof(struct A090_extra_size) == 1, "");
_Static_assert(sizeof(A091) == 2, "");
_Static_assert(_Alignof(A091) == 2, "");
_Static_assert(sizeof(struct A091_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A091_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A091_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A091_extra_packed) == 1, "");
_Static_assert(sizeof(struct A091_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A091_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A091_extra_size) == 4, "");
_Static_assert(_Alignof(struct A091_extra_size) == 1, "");
_Static_assert(sizeof(A092) == 2, "");
_Static_assert(_Alignof(A092) == 2, "");
_Static_assert(sizeof(struct A092_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A092_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A092_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A092_extra_packed) == 1, "");
_Static_assert(sizeof(struct A092_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A092_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A092_extra_size) == 4, "");
_Static_assert(_Alignof(struct A092_extra_size) == 1, "");
_Static_assert(sizeof(A093) == 2, "");
_Static_assert(_Alignof(A093) == 2, "");
_Static_assert(sizeof(struct A093_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A093_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A093_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A093_extra_packed) == 1, "");
_Static_assert(sizeof(struct A093_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A093_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A093_extra_size) == 4, "");
_Static_assert(_Alignof(struct A093_extra_size) == 1, "");
_Static_assert(sizeof(A094) == 2, "");
_Static_assert(_Alignof(A094) == 2, "");
_Static_assert(sizeof(struct A094_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A094_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A094_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A094_extra_packed) == 1, "");
_Static_assert(sizeof(struct A094_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A094_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A094_extra_size) == 4, "");
_Static_assert(_Alignof(struct A094_extra_size) == 1, "");
_Static_assert(sizeof(A095) == 2, "");
_Static_assert(_Alignof(A095) == 2, "");
_Static_assert(sizeof(struct A095_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A095_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A095_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A095_extra_packed) == 1, "");
_Static_assert(sizeof(struct A095_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A095_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A095_extra_size) == 4, "");
_Static_assert(_Alignof(struct A095_extra_size) == 1, "");
_Static_assert(sizeof(A096) == 2, "");
_Static_assert(_Alignof(A096) == 2, "");
_Static_assert(sizeof(struct A096_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A096_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A096_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A096_extra_packed) == 1, "");
_Static_assert(sizeof(struct A096_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A096_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A096_extra_size) == 4, "");
_Static_assert(_Alignof(struct A096_extra_size) == 1, "");
_Static_assert(sizeof(A101) == 4, "");
_Static_assert(_Alignof(A101) == 4, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 6, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
_Static_assert(sizeof(A102) == 4, "");
_Static_assert(_Alignof(A102) == 4, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 6, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
_Static_assert(sizeof(A103) == 4, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 6, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
_Static_assert(sizeof(A104) == 4, "");
_Static_assert(_Alignof(A104) == 4, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 6, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 4, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
_Static_assert(sizeof(A106) == 4, "");
_Static_assert(_Alignof(A106) == 4, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 6, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
_Static_assert(sizeof(A107) == 4, "");
_Static_assert(_Alignof(A107) == 4, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 6, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
_Static_assert(sizeof(A108) == 4, "");
_Static_assert(_Alignof(A108) == 4, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 6, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
_Static_assert(sizeof(A109) == 4, "");
_Static_assert(_Alignof(A109) == 4, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 6, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
_Static_assert(sizeof(A110) == 4, "");
_Static_assert(_Alignof(A110) == 4, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 6, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
_Static_assert(sizeof(A111) == 4, "");
_Static_assert(_Alignof(A111) == 4, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 6, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
_Static_assert(sizeof(A112) == 4, "");
_Static_assert(_Alignof(A112) == 4, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 6, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
_Static_assert(sizeof(A113) == 4, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 6, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
_Static_assert(sizeof(A114) == 4, "");
_Static_assert(_Alignof(A114) == 4, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 6, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
_Static_assert(sizeof(A115) == 4, "");
_Static_assert(_Alignof(A115) == 4, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 6, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
_Static_assert(sizeof(A116) == 4, "");
_Static_assert(_Alignof(A116) == 4, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 6, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
_Static_assert(sizeof(A121) == 8, "");
_Static_assert(_Alignof(A121) == 4, "");
_Static_assert(sizeof(struct A121_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A121_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A121_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A121_extra_packed) == 1, "");
_Static_assert(sizeof(struct A121_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A121_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A121_extra_size) == 10, "");
_Static_assert(_Alignof(struct A121_extra_size) == 1, "");
_Static_assert(sizeof(A122) == 8, "");
_Static_assert(_Alignof(A122) == 4, "");
_Static_assert(sizeof(struct A122_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A122_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A122_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A122_extra_packed) == 1, "");
_Static_assert(sizeof(struct A122_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A122_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A122_extra_size) == 10, "");
_Static_assert(_Alignof(struct A122_extra_size) == 1, "");
_Static_assert(sizeof(A123) == 8, "");
_Static_assert(_Alignof(A123) == 4, "");
_Static_assert(sizeof(struct A123_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A123_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A123_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A123_extra_packed) == 1, "");
_Static_assert(sizeof(struct A123_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A123_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A123_extra_size) == 10, "");
_Static_assert(_Alignof(struct A123_extra_size) == 1, "");
_Static_assert(sizeof(A124) == 8, "");
_Static_assert(_Alignof(A124) == 4, "");
_Static_assert(sizeof(struct A124_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A124_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A124_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A124_extra_packed) == 1, "");
_Static_assert(sizeof(struct A124_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A124_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A124_extra_size) == 10, "");
_Static_assert(_Alignof(struct A124_extra_size) == 1, "");
_Static_assert(sizeof(A125) == 8, "");
_Static_assert(_Alignof(A125) == 4, "");
_Static_assert(sizeof(struct A125_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A125_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A125_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A125_extra_packed) == 1, "");
_Static_assert(sizeof(struct A125_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A125_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A125_extra_size) == 10, "");
_Static_assert(_Alignof(struct A125_extra_size) == 1, "");
_Static_assert(sizeof(A126) == 8, "");
_Static_assert(_Alignof(A126) == 4, "");
_Static_assert(sizeof(struct A126_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A126_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A126_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A126_extra_packed) == 1, "");
_Static_assert(sizeof(struct A126_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A126_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A126_extra_size) == 10, "");
_Static_assert(_Alignof(struct A126_extra_size) == 1, "");
_Static_assert(sizeof(A127) == 8, "");
_Static_assert(_Alignof(A127) == 4, "");
_Static_assert(sizeof(struct A127_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A127_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A127_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A127_extra_packed) == 1, "");
_Static_assert(sizeof(struct A127_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A127_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A127_extra_size) == 10, "");
_Static_assert(_Alignof(struct A127_extra_size) == 1, "");
_Static_assert(sizeof(A128) == 8, "");
_Static_assert(_Alignof(A128) == 4, "");
_Static_assert(sizeof(struct A128_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A128_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A128_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A128_extra_packed) == 1, "");
_Static_assert(sizeof(struct A128_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A128_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A128_extra_size) == 10, "");
_Static_assert(_Alignof(struct A128_extra_size) == 1, "");
_Static_assert(sizeof(A129) == 8, "");
_Static_assert(_Alignof(A129) == 4, "");
_Static_assert(sizeof(struct A129_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A129_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A129_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A129_extra_packed) == 1, "");
_Static_assert(sizeof(struct A129_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A129_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A129_extra_size) == 10, "");
_Static_assert(_Alignof(struct A129_extra_size) == 1, "");
_Static_assert(sizeof(A130) == 8, "");
_Static_assert(_Alignof(A130) == 4, "");
_Static_assert(sizeof(struct A130_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A130_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A130_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A130_extra_packed) == 1, "");
_Static_assert(sizeof(struct A130_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A130_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A130_extra_size) == 10, "");
_Static_assert(_Alignof(struct A130_extra_size) == 1, "");
_Static_assert(sizeof(A131) == 8, "");
_Static_assert(_Alignof(A131) == 4, "");
_Static_assert(sizeof(struct A131_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A131_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A131_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A131_extra_packed) == 1, "");
_Static_assert(sizeof(struct A131_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A131_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A131_extra_size) == 10, "");
_Static_assert(_Alignof(struct A131_extra_size) == 1, "");
_Static_assert(sizeof(A132) == 8, "");
_Static_assert(_Alignof(A132) == 4, "");
_Static_assert(sizeof(struct A132_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A132_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A132_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A132_extra_packed) == 1, "");
_Static_assert(sizeof(struct A132_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A132_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A132_extra_size) == 10, "");
_Static_assert(_Alignof(struct A132_extra_size) == 1, "");
_Static_assert(sizeof(A133) == 8, "");
_Static_assert(_Alignof(A133) == 4, "");
_Static_assert(sizeof(struct A133_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A133_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A133_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A133_extra_packed) == 1, "");
_Static_assert(sizeof(struct A133_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A133_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A133_extra_size) == 10, "");
_Static_assert(_Alignof(struct A133_extra_size) == 1, "");
_Static_assert(sizeof(A134) == 8, "");
_Static_assert(_Alignof(A134) == 4, "");
_Static_assert(sizeof(struct A134_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A134_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A134_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A134_extra_packed) == 1, "");
_Static_assert(sizeof(struct A134_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A134_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A134_extra_size) == 10, "");
_Static_assert(_Alignof(struct A134_extra_size) == 1, "");
_Static_assert(sizeof(A135) == 8, "");
_Static_assert(_Alignof(A135) == 4, "");
_Static_assert(sizeof(struct A135_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A135_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A135_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A135_extra_packed) == 1, "");
_Static_assert(sizeof(struct A135_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A135_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A135_extra_size) == 10, "");
_Static_assert(_Alignof(struct A135_extra_size) == 1, "");
_Static_assert(sizeof(A136) == 8, "");
_Static_assert(_Alignof(A136) == 4, "");
_Static_assert(sizeof(struct A136_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A136_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A136_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A136_extra_packed) == 1, "");
_Static_assert(sizeof(struct A136_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A136_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A136_extra_size) == 10, "");
_Static_assert(_Alignof(struct A136_extra_size) == 1, "");
_Static_assert(sizeof(A141) == 8, "");
_Static_assert(_Alignof(A141) == 4, "");
_Static_assert(sizeof(struct A141_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A141_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A141_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A141_extra_packed) == 1, "");
_Static_assert(sizeof(struct A141_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A141_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A141_extra_size) == 10, "");
_Static_assert(_Alignof(struct A141_extra_size) == 1, "");
_Static_assert(sizeof(A142) == 8, "");
_Static_assert(_Alignof(A142) == 4, "");
_Static_assert(sizeof(struct A142_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A142_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A142_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A142_extra_packed) == 1, "");
_Static_assert(sizeof(struct A142_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A142_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A142_extra_size) == 10, "");
_Static_assert(_Alignof(struct A142_extra_size) == 1, "");
_Static_assert(sizeof(A143) == 8, "");
_Static_assert(_Alignof(A143) == 4, "");
_Static_assert(sizeof(struct A143_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A143_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A143_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A143_extra_packed) == 1, "");
_Static_assert(sizeof(struct A143_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A143_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A143_extra_size) == 10, "");
_Static_assert(_Alignof(struct A143_extra_size) == 1, "");
_Static_assert(sizeof(A144) == 8, "");
_Static_assert(_Alignof(A144) == 4, "");
_Static_assert(sizeof(struct A144_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A144_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A144_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A144_extra_packed) == 1, "");
_Static_assert(sizeof(struct A144_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A144_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A144_extra_size) == 10, "");
_Static_assert(_Alignof(struct A144_extra_size) == 1, "");
_Static_assert(sizeof(A145) == 8, "");
_Static_assert(_Alignof(A145) == 4, "");
_Static_assert(sizeof(struct A145_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A145_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A145_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A145_extra_packed) == 1, "");
_Static_assert(sizeof(struct A145_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A145_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A145_extra_size) == 10, "");
_Static_assert(_Alignof(struct A145_extra_size) == 1, "");
_Static_assert(sizeof(A146) == 8, "");
_Static_assert(_Alignof(A146) == 4, "");
_Static_assert(sizeof(struct A146_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A146_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A146_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A146_extra_packed) == 1, "");
_Static_assert(sizeof(struct A146_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A146_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A146_extra_size) == 10, "");
_Static_assert(_Alignof(struct A146_extra_size) == 1, "");
_Static_assert(sizeof(A147) == 8, "");
_Static_assert(_Alignof(A147) == 4, "");
_Static_assert(sizeof(struct A147_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A147_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A147_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A147_extra_packed) == 1, "");
_Static_assert(sizeof(struct A147_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A147_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A147_extra_size) == 10, "");
_Static_assert(_Alignof(struct A147_extra_size) == 1, "");
_Static_assert(sizeof(A148) == 8, "");
_Static_assert(_Alignof(A148) == 4, "");
_Static_assert(sizeof(struct A148_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A148_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A148_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A148_extra_packed) == 1, "");
_Static_assert(sizeof(struct A148_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A148_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A148_extra_size) == 10, "");
_Static_assert(_Alignof(struct A148_extra_size) == 1, "");
_Static_assert(sizeof(A149) == 8, "");
_Static_assert(_Alignof(A149) == 4, "");
_Static_assert(sizeof(struct A149_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A149_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A149_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A149_extra_packed) == 1, "");
_Static_assert(sizeof(struct A149_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A149_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A149_extra_size) == 10, "");
_Static_assert(_Alignof(struct A149_extra_size) == 1, "");
_Static_assert(sizeof(A150) == 8, "");
_Static_assert(_Alignof(A150) == 4, "");
_Static_assert(sizeof(struct A150_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A150_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A150_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A150_extra_packed) == 1, "");
_Static_assert(sizeof(struct A150_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A150_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A150_extra_size) == 10, "");
_Static_assert(_Alignof(struct A150_extra_size) == 1, "");
_Static_assert(sizeof(A151) == 8, "");
_Static_assert(_Alignof(A151) == 4, "");
_Static_assert(sizeof(struct A151_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A151_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A151_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A151_extra_packed) == 1, "");
_Static_assert(sizeof(struct A151_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A151_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A151_extra_size) == 10, "");
_Static_assert(_Alignof(struct A151_extra_size) == 1, "");
_Static_assert(sizeof(A152) == 8, "");
_Static_assert(_Alignof(A152) == 4, "");
_Static_assert(sizeof(struct A152_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A152_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A152_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A152_extra_packed) == 1, "");
_Static_assert(sizeof(struct A152_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A152_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A152_extra_size) == 10, "");
_Static_assert(_Alignof(struct A152_extra_size) == 1, "");
_Static_assert(sizeof(A153) == 8, "");
_Static_assert(_Alignof(A153) == 4, "");
_Static_assert(sizeof(struct A153_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A153_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A153_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A153_extra_packed) == 1, "");
_Static_assert(sizeof(struct A153_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A153_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A153_extra_size) == 10, "");
_Static_assert(_Alignof(struct A153_extra_size) == 1, "");
_Static_assert(sizeof(A154) == 8, "");
_Static_assert(_Alignof(A154) == 4, "");
_Static_assert(sizeof(struct A154_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A154_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A154_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A154_extra_packed) == 1, "");
_Static_assert(sizeof(struct A154_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A154_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A154_extra_size) == 10, "");
_Static_assert(_Alignof(struct A154_extra_size) == 1, "");
_Static_assert(sizeof(A155) == 8, "");
_Static_assert(_Alignof(A155) == 4, "");
_Static_assert(sizeof(struct A155_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A155_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A155_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A155_extra_packed) == 1, "");
_Static_assert(sizeof(struct A155_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A155_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A155_extra_size) == 10, "");
_Static_assert(_Alignof(struct A155_extra_size) == 1, "");
_Static_assert(sizeof(A156) == 8, "");
_Static_assert(_Alignof(A156) == 4, "");
_Static_assert(sizeof(struct A156_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A156_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A156_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A156_extra_packed) == 1, "");
_Static_assert(sizeof(struct A156_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A156_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A156_extra_size) == 10, "");
_Static_assert(_Alignof(struct A156_extra_size) == 1, "");
_Static_assert(sizeof(B000) == 4, "");
_Static_assert(_Alignof(B000) == 4, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B000_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 6, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
_Static_assert(sizeof(B001) == 4, "");
_Static_assert(_Alignof(B001) == 4, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B001_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 6, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
_Static_assert(sizeof(B002) == 4, "");
_Static_assert(_Alignof(B002) == 4, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B002_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 6, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
_Static_assert(sizeof(B003) == 4, "");
_Static_assert(_Alignof(B003) == 4, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B003_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 6, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 4, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 4, "");
_Static_assert(_Alignof(B005) == 4, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B005_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 6, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
_Static_assert(sizeof(B006) == 4, "");
_Static_assert(_Alignof(B006) == 4, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B006_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 6, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
_Static_assert(sizeof(B007) == 4, "");
_Static_assert(_Alignof(B007) == 4, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B007_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 6, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
_Static_assert(sizeof(B008) == 4, "");
_Static_assert(_Alignof(B008) == 4, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B008_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 6, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
_Static_assert(sizeof(B009) == 4, "");
_Static_assert(_Alignof(B009) == 4, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B009_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 6, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
_Static_assert(sizeof(B010) == 4, "");
_Static_assert(_Alignof(B010) == 4, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B010_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 6, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
_Static_assert(sizeof(B011) == 4, "");
_Static_assert(_Alignof(B011) == 4, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B011_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 6, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
_Static_assert(sizeof(B012) == 4, "");
_Static_assert(_Alignof(B012) == 4, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B012_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 6, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
_Static_assert(sizeof(B013) == 4, "");
_Static_assert(_Alignof(B013) == 4, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B013_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 6, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
_Static_assert(sizeof(B014) == 4, "");
_Static_assert(_Alignof(B014) == 4, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B014_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 6, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
_Static_assert(sizeof(B015) == 4, "");
_Static_assert(_Alignof(B015) == 4, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B015_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 6, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
_Static_assert(sizeof(B016) == 4, "");
_Static_assert(_Alignof(B016) == 4, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B016_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 6, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
_Static_assert(sizeof(B021) == 4, "");
_Static_assert(_Alignof(B021) == 4, "");
_Static_assert(sizeof(struct B021_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B021_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B021_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B021_extra_packed) == 1, "");
_Static_assert(sizeof(struct B021_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B021_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B021_extra_size) == 6, "");
_Static_assert(_Alignof(struct B021_extra_size) == 1, "");
_Static_assert(sizeof(B022) == 4, "");
_Static_assert(_Alignof(B022) == 4, "");
_Static_assert(sizeof(struct B022_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B022_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B022_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B022_extra_packed) == 1, "");
_Static_assert(sizeof(struct B022_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B022_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B022_extra_size) == 6, "");
_Static_assert(_Alignof(struct B022_extra_size) == 1, "");
_Static_assert(sizeof(B023) == 4, "");
_Static_assert(_Alignof(B023) == 4, "");
_Static_assert(sizeof(struct B023_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B023_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B023_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B023_extra_packed) == 1, "");
_Static_assert(sizeof(struct B023_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B023_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B023_extra_size) == 6, "");
_Static_assert(_Alignof(struct B023_extra_size) == 1, "");
_Static_assert(sizeof(B024) == 4, "");
_Static_assert(_Alignof(B024) == 4, "");
_Static_assert(sizeof(struct B024_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B024_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B024_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B024_extra_packed) == 1, "");
_Static_assert(sizeof(struct B024_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B024_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B024_extra_size) == 6, "");
_Static_assert(_Alignof(struct B024_extra_size) == 1, "");
_Static_assert(sizeof(B025) == 4, "");
_Static_assert(_Alignof(B025) == 4, "");
_Static_assert(sizeof(struct B025_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B025_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B025_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B025_extra_packed) == 1, "");
_Static_assert(sizeof(struct B025_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B025_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B025_extra_size) == 6, "");
_Static_assert(_Alignof(struct B025_extra_size) == 1, "");
_Static_assert(sizeof(B026) == 4, "");
_Static_assert(_Alignof(B026) == 4, "");
_Static_assert(sizeof(struct B026_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B026_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B026_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B026_extra_packed) == 1, "");
_Static_assert(sizeof(struct B026_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B026_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B026_extra_size) == 6, "");
_Static_assert(_Alignof(struct B026_extra_size) == 1, "");
_Static_assert(sizeof(B027) == 4, "");
_Static_assert(_Alignof(B027) == 4, "");
_Static_assert(sizeof(struct B027_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B027_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B027_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B027_extra_packed) == 1, "");
_Static_assert(sizeof(struct B027_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B027_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B027_extra_size) == 6, "");
_Static_assert(_Alignof(struct B027_extra_size) == 1, "");
_Static_assert(sizeof(B028) == 4, "");
_Static_assert(_Alignof(B028) == 4, "");
_Static_assert(sizeof(struct B028_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B028_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B028_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B028_extra_packed) == 1, "");
_Static_assert(sizeof(struct B028_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B028_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B028_extra_size) == 6, "");
_Static_assert(_Alignof(struct B028_extra_size) == 1, "");
_Static_assert(sizeof(B029) == 4, "");
_Static_assert(_Alignof(B029) == 4, "");
_Static_assert(sizeof(struct B029_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B029_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B029_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B029_extra_packed) == 1, "");
_Static_assert(sizeof(struct B029_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B029_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B029_extra_size) == 6, "");
_Static_assert(_Alignof(struct B029_extra_size) == 1, "");
_Static_assert(sizeof(B030) == 4, "");
_Static_assert(_Alignof(B030) == 4, "");
_Static_assert(sizeof(struct B030_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B030_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B030_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B030_extra_packed) == 1, "");
_Static_assert(sizeof(struct B030_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B030_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B030_extra_size) == 6, "");
_Static_assert(_Alignof(struct B030_extra_size) == 1, "");
_Static_assert(sizeof(B031) == 4, "");
_Static_assert(_Alignof(B031) == 4, "");
_Static_assert(sizeof(struct B031_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B031_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B031_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B031_extra_packed) == 1, "");
_Static_assert(sizeof(struct B031_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B031_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B031_extra_size) == 6, "");
_Static_assert(_Alignof(struct B031_extra_size) == 1, "");
_Static_assert(sizeof(B032) == 4, "");
_Static_assert(_Alignof(B032) == 4, "");
_Static_assert(sizeof(struct B032_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B032_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B032_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B032_extra_packed) == 1, "");
_Static_assert(sizeof(struct B032_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B032_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B032_extra_size) == 6, "");
_Static_assert(_Alignof(struct B032_extra_size) == 1, "");
_Static_assert(sizeof(B033) == 4, "");
_Static_assert(_Alignof(B033) == 4, "");
_Static_assert(sizeof(struct B033_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B033_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B033_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B033_extra_packed) == 1, "");
_Static_assert(sizeof(struct B033_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B033_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B033_extra_size) == 6, "");
_Static_assert(_Alignof(struct B033_extra_size) == 1, "");
_Static_assert(sizeof(B034) == 4, "");
_Static_assert(_Alignof(B034) == 4, "");
_Static_assert(sizeof(struct B034_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B034_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B034_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B034_extra_packed) == 1, "");
_Static_assert(sizeof(struct B034_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B034_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B034_extra_size) == 6, "");
_Static_assert(_Alignof(struct B034_extra_size) == 1, "");
_Static_assert(sizeof(B035) == 4, "");
_Static_assert(_Alignof(B035) == 4, "");
_Static_assert(sizeof(struct B035_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B035_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B035_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B035_extra_packed) == 1, "");
_Static_assert(sizeof(struct B035_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B035_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B035_extra_size) == 6, "");
_Static_assert(_Alignof(struct B035_extra_size) == 1, "");
_Static_assert(sizeof(B036) == 4, "");
_Static_assert(_Alignof(B036) == 4, "");
_Static_assert(sizeof(struct B036_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B036_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B036_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B036_extra_packed) == 1, "");
_Static_assert(sizeof(struct B036_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B036_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B036_extra_size) == 6, "");
_Static_assert(_Alignof(struct B036_extra_size) == 1, "");
_Static_assert(sizeof(B041) == 8, "");
_Static_assert(_Alignof(B041) == 4, "");
_Static_assert(sizeof(struct B041_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B041_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B041_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B041_extra_packed) == 1, "");
_Static_assert(sizeof(struct B041_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B041_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B041_extra_size) == 10, "");
_Static_assert(_Alignof(struct B041_extra_size) == 1, "");
_Static_assert(sizeof(B042) == 8, "");
_Static_assert(_Alignof(B042) == 4, "");
_Static_assert(sizeof(struct B042_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B042_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B042_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B042_extra_packed) == 1, "");
_Static_assert(sizeof(struct B042_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B042_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B042_extra_size) == 10, "");
_Static_assert(_Alignof(struct B042_extra_size) == 1, "");
_Static_assert(sizeof(B043) == 8, "");
_Static_assert(_Alignof(B043) == 4, "");
_Static_assert(sizeof(struct B043_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B043_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B043_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B043_extra_packed) == 1, "");
_Static_assert(sizeof(struct B043_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B043_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B043_extra_size) == 10, "");
_Static_assert(_Alignof(struct B043_extra_size) == 1, "");
_Static_assert(sizeof(B044) == 8, "");
_Static_assert(_Alignof(B044) == 4, "");
_Static_assert(sizeof(struct B044_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B044_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B044_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B044_extra_packed) == 1, "");
_Static_assert(sizeof(struct B044_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B044_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B044_extra_size) == 10, "");
_Static_assert(_Alignof(struct B044_extra_size) == 1, "");
_Static_assert(sizeof(B045) == 8, "");
_Static_assert(_Alignof(B045) == 4, "");
_Static_assert(sizeof(struct B045_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B045_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B045_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B045_extra_packed) == 1, "");
_Static_assert(sizeof(struct B045_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B045_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B045_extra_size) == 10, "");
_Static_assert(_Alignof(struct B045_extra_size) == 1, "");
_Static_assert(sizeof(B046) == 8, "");
_Static_assert(_Alignof(B046) == 4, "");
_Static_assert(sizeof(struct B046_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B046_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B046_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B046_extra_packed) == 1, "");
_Static_assert(sizeof(struct B046_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B046_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B046_extra_size) == 10, "");
_Static_assert(_Alignof(struct B046_extra_size) == 1, "");
_Static_assert(sizeof(B047) == 8, "");
_Static_assert(_Alignof(B047) == 4, "");
_Static_assert(sizeof(struct B047_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B047_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B047_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B047_extra_packed) == 1, "");
_Static_assert(sizeof(struct B047_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B047_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B047_extra_size) == 10, "");
_Static_assert(_Alignof(struct B047_extra_size) == 1, "");
_Static_assert(sizeof(B048) == 8, "");
_Static_assert(_Alignof(B048) == 4, "");
_Static_assert(sizeof(struct B048_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B048_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B048_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B048_extra_packed) == 1, "");
_Static_assert(sizeof(struct B048_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B048_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B048_extra_size) == 10, "");
_Static_assert(_Alignof(struct B048_extra_size) == 1, "");
_Static_assert(sizeof(B049) == 8, "");
_Static_assert(_Alignof(B049) == 4, "");
_Static_assert(sizeof(struct B049_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B049_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B049_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B049_extra_packed) == 1, "");
_Static_assert(sizeof(struct B049_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B049_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B049_extra_size) == 10, "");
_Static_assert(_Alignof(struct B049_extra_size) == 1, "");
_Static_assert(sizeof(B050) == 8, "");
_Static_assert(_Alignof(B050) == 4, "");
_Static_assert(sizeof(struct B050_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B050_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B050_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B050_extra_packed) == 1, "");
_Static_assert(sizeof(struct B050_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B050_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B050_extra_size) == 10, "");
_Static_assert(_Alignof(struct B050_extra_size) == 1, "");
_Static_assert(sizeof(B051) == 8, "");
_Static_assert(_Alignof(B051) == 4, "");
_Static_assert(sizeof(struct B051_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B051_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B051_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B051_extra_packed) == 1, "");
_Static_assert(sizeof(struct B051_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B051_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B051_extra_size) == 10, "");
_Static_assert(_Alignof(struct B051_extra_size) == 1, "");
_Static_assert(sizeof(B052) == 8, "");
_Static_assert(_Alignof(B052) == 4, "");
_Static_assert(sizeof(struct B052_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B052_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B052_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B052_extra_packed) == 1, "");
_Static_assert(sizeof(struct B052_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B052_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B052_extra_size) == 10, "");
_Static_assert(_Alignof(struct B052_extra_size) == 1, "");
_Static_assert(sizeof(B053) == 8, "");
_Static_assert(_Alignof(B053) == 4, "");
_Static_assert(sizeof(struct B053_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B053_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B053_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B053_extra_packed) == 1, "");
_Static_assert(sizeof(struct B053_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B053_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B053_extra_size) == 10, "");
_Static_assert(_Alignof(struct B053_extra_size) == 1, "");
_Static_assert(sizeof(B054) == 8, "");
_Static_assert(_Alignof(B054) == 4, "");
_Static_assert(sizeof(struct B054_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B054_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B054_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B054_extra_packed) == 1, "");
_Static_assert(sizeof(struct B054_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B054_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B054_extra_size) == 10, "");
_Static_assert(_Alignof(struct B054_extra_size) == 1, "");
_Static_assert(sizeof(B055) == 8, "");
_Static_assert(_Alignof(B055) == 4, "");
_Static_assert(sizeof(struct B055_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B055_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B055_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B055_extra_packed) == 1, "");
_Static_assert(sizeof(struct B055_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B055_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B055_extra_size) == 10, "");
_Static_assert(_Alignof(struct B055_extra_size) == 1, "");
_Static_assert(sizeof(B056) == 8, "");
_Static_assert(_Alignof(B056) == 4, "");
_Static_assert(sizeof(struct B056_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B056_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B056_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B056_extra_packed) == 1, "");
_Static_assert(sizeof(struct B056_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B056_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B056_extra_size) == 10, "");
_Static_assert(_Alignof(struct B056_extra_size) == 1, "");
_Static_assert(sizeof(B061) == 8, "");
_Static_assert(_Alignof(B061) == 4, "");
_Static_assert(sizeof(struct B061_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B061_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B061_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B061_extra_packed) == 1, "");
_Static_assert(sizeof(struct B061_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B061_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B061_extra_size) == 10, "");
_Static_assert(_Alignof(struct B061_extra_size) == 1, "");
_Static_assert(sizeof(B062) == 8, "");
_Static_assert(_Alignof(B062) == 4, "");
_Static_assert(sizeof(struct B062_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B062_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B062_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B062_extra_packed) == 1, "");
_Static_assert(sizeof(struct B062_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B062_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B062_extra_size) == 10, "");
_Static_assert(_Alignof(struct B062_extra_size) == 1, "");
_Static_assert(sizeof(B063) == 8, "");
_Static_assert(_Alignof(B063) == 4, "");
_Static_assert(sizeof(struct B063_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B063_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B063_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B063_extra_packed) == 1, "");
_Static_assert(sizeof(struct B063_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B063_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B063_extra_size) == 10, "");
_Static_assert(_Alignof(struct B063_extra_size) == 1, "");
_Static_assert(sizeof(B064) == 8, "");
_Static_assert(_Alignof(B064) == 4, "");
_Static_assert(sizeof(struct B064_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B064_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B064_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B064_extra_packed) == 1, "");
_Static_assert(sizeof(struct B064_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B064_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B064_extra_size) == 10, "");
_Static_assert(_Alignof(struct B064_extra_size) == 1, "");
_Static_assert(sizeof(B065) == 8, "");
_Static_assert(_Alignof(B065) == 4, "");
_Static_assert(sizeof(struct B065_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B065_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B065_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B065_extra_packed) == 1, "");
_Static_assert(sizeof(struct B065_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B065_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B065_extra_size) == 10, "");
_Static_assert(_Alignof(struct B065_extra_size) == 1, "");
_Static_assert(sizeof(B066) == 8, "");
_Static_assert(_Alignof(B066) == 4, "");
_Static_assert(sizeof(struct B066_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B066_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B066_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B066_extra_packed) == 1, "");
_Static_assert(sizeof(struct B066_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B066_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B066_extra_size) == 10, "");
_Static_assert(_Alignof(struct B066_extra_size) == 1, "");
_Static_assert(sizeof(B067) == 8, "");
_Static_assert(_Alignof(B067) == 4, "");
_Static_assert(sizeof(struct B067_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B067_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B067_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B067_extra_packed) == 1, "");
_Static_assert(sizeof(struct B067_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B067_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B067_extra_size) == 10, "");
_Static_assert(_Alignof(struct B067_extra_size) == 1, "");
_Static_assert(sizeof(B068) == 8, "");
_Static_assert(_Alignof(B068) == 4, "");
_Static_assert(sizeof(struct B068_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B068_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B068_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B068_extra_packed) == 1, "");
_Static_assert(sizeof(struct B068_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B068_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B068_extra_size) == 10, "");
_Static_assert(_Alignof(struct B068_extra_size) == 1, "");
_Static_assert(sizeof(B069) == 8, "");
_Static_assert(_Alignof(B069) == 4, "");
_Static_assert(sizeof(struct B069_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B069_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B069_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B069_extra_packed) == 1, "");
_Static_assert(sizeof(struct B069_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B069_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B069_extra_size) == 10, "");
_Static_assert(_Alignof(struct B069_extra_size) == 1, "");
_Static_assert(sizeof(B070) == 8, "");
_Static_assert(_Alignof(B070) == 4, "");
_Static_assert(sizeof(struct B070_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B070_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B070_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B070_extra_packed) == 1, "");
_Static_assert(sizeof(struct B070_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B070_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B070_extra_size) == 10, "");
_Static_assert(_Alignof(struct B070_extra_size) == 1, "");
_Static_assert(sizeof(B071) == 8, "");
_Static_assert(_Alignof(B071) == 4, "");
_Static_assert(sizeof(struct B071_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B071_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B071_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B071_extra_packed) == 1, "");
_Static_assert(sizeof(struct B071_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B071_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B071_extra_size) == 10, "");
_Static_assert(_Alignof(struct B071_extra_size) == 1, "");
_Static_assert(sizeof(B072) == 8, "");
_Static_assert(_Alignof(B072) == 4, "");
_Static_assert(sizeof(struct B072_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B072_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B072_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B072_extra_packed) == 1, "");
_Static_assert(sizeof(struct B072_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B072_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B072_extra_size) == 10, "");
_Static_assert(_Alignof(struct B072_extra_size) == 1, "");
_Static_assert(sizeof(B073) == 8, "");
_Static_assert(_Alignof(B073) == 4, "");
_Static_assert(sizeof(struct B073_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B073_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B073_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B073_extra_packed) == 1, "");
_Static_assert(sizeof(struct B073_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B073_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B073_extra_size) == 10, "");
_Static_assert(_Alignof(struct B073_extra_size) == 1, "");
_Static_assert(sizeof(B074) == 8, "");
_Static_assert(_Alignof(B074) == 4, "");
_Static_assert(sizeof(struct B074_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B074_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B074_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B074_extra_packed) == 1, "");
_Static_assert(sizeof(struct B074_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B074_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B074_extra_size) == 10, "");
_Static_assert(_Alignof(struct B074_extra_size) == 1, "");
_Static_assert(sizeof(B075) == 8, "");
_Static_assert(_Alignof(B075) == 4, "");
_Static_assert(sizeof(struct B075_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B075_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B075_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B075_extra_packed) == 1, "");
_Static_assert(sizeof(struct B075_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B075_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B075_extra_size) == 10, "");
_Static_assert(_Alignof(struct B075_extra_size) == 1, "");
_Static_assert(sizeof(B076) == 8, "");
_Static_assert(_Alignof(B076) == 4, "");
_Static_assert(sizeof(struct B076_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B076_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B076_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B076_extra_packed) == 1, "");
_Static_assert(sizeof(struct B076_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B076_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B076_extra_size) == 10, "");
_Static_assert(_Alignof(struct B076_extra_size) == 1, "");
_Static_assert(sizeof(B081) == 4, "");
_Static_assert(_Alignof(B081) == 4, "");
_Static_assert(sizeof(struct B081_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B081_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B081_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B081_extra_packed) == 1, "");
_Static_assert(sizeof(struct B081_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B081_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B081_extra_size) == 6, "");
_Static_assert(_Alignof(struct B081_extra_size) == 1, "");
_Static_assert(sizeof(B082) == 4, "");
_Static_assert(_Alignof(B082) == 4, "");
_Static_assert(sizeof(struct B082_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B082_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B082_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B082_extra_packed) == 1, "");
_Static_assert(sizeof(struct B082_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B082_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B082_extra_size) == 6, "");
_Static_assert(_Alignof(struct B082_extra_size) == 1, "");
_Static_assert(sizeof(B083) == 4, "");
_Static_assert(_Alignof(B083) == 4, "");
_Static_assert(sizeof(struct B083_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B083_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B083_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B083_extra_packed) == 1, "");
_Static_assert(sizeof(struct B083_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B083_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B083_extra_size) == 6, "");
_Static_assert(_Alignof(struct B083_extra_size) == 1, "");
_Static_assert(sizeof(B084) == 4, "");
_Static_assert(_Alignof(B084) == 4, "");
_Static_assert(sizeof(struct B084_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B084_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B084_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B084_extra_packed) == 1, "");
_Static_assert(sizeof(struct B084_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B084_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B084_extra_size) == 6, "");
_Static_assert(_Alignof(struct B084_extra_size) == 1, "");
_Static_assert(sizeof(B085) == 4, "");
_Static_assert(_Alignof(B085) == 4, "");
_Static_assert(sizeof(struct B085_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B085_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B085_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B085_extra_packed) == 1, "");
_Static_assert(sizeof(struct B085_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B085_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B085_extra_size) == 6, "");
_Static_assert(_Alignof(struct B085_extra_size) == 1, "");
_Static_assert(sizeof(B086) == 4, "");
_Static_assert(_Alignof(B086) == 4, "");
_Static_assert(sizeof(struct B086_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B086_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B086_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B086_extra_packed) == 1, "");
_Static_assert(sizeof(struct B086_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B086_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B086_extra_size) == 6, "");
_Static_assert(_Alignof(struct B086_extra_size) == 1, "");
_Static_assert(sizeof(B087) == 4, "");
_Static_assert(_Alignof(B087) == 4, "");
_Static_assert(sizeof(struct B087_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B087_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B087_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B087_extra_packed) == 1, "");
_Static_assert(sizeof(struct B087_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B087_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B087_extra_size) == 6, "");
_Static_assert(_Alignof(struct B087_extra_size) == 1, "");
_Static_assert(sizeof(B088) == 4, "");
_Static_assert(_Alignof(B088) == 4, "");
_Static_assert(sizeof(struct B088_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B088_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B088_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B088_extra_packed) == 1, "");
_Static_assert(sizeof(struct B088_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B088_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B088_extra_size) == 6, "");
_Static_assert(_Alignof(struct B088_extra_size) == 1, "");
_Static_assert(sizeof(B089) == 4, "");
_Static_assert(_Alignof(B089) == 4, "");
_Static_assert(sizeof(struct B089_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B089_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B089_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B089_extra_packed) == 1, "");
_Static_assert(sizeof(struct B089_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B089_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B089_extra_size) == 6, "");
_Static_assert(_Alignof(struct B089_extra_size) == 1, "");
_Static_assert(sizeof(B090) == 4, "");
_Static_assert(_Alignof(B090) == 4, "");
_Static_assert(sizeof(struct B090_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B090_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B090_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B090_extra_packed) == 1, "");
_Static_assert(sizeof(struct B090_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B090_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B090_extra_size) == 6, "");
_Static_assert(_Alignof(struct B090_extra_size) == 1, "");
_Static_assert(sizeof(B091) == 4, "");
_Static_assert(_Alignof(B091) == 4, "");
_Static_assert(sizeof(struct B091_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B091_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B091_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B091_extra_packed) == 1, "");
_Static_assert(sizeof(struct B091_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B091_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B091_extra_size) == 6, "");
_Static_assert(_Alignof(struct B091_extra_size) == 1, "");
_Static_assert(sizeof(B092) == 4, "");
_Static_assert(_Alignof(B092) == 4, "");
_Static_assert(sizeof(struct B092_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B092_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B092_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B092_extra_packed) == 1, "");
_Static_assert(sizeof(struct B092_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B092_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B092_extra_size) == 6, "");
_Static_assert(_Alignof(struct B092_extra_size) == 1, "");
_Static_assert(sizeof(B093) == 4, "");
_Static_assert(_Alignof(B093) == 4, "");
_Static_assert(sizeof(struct B093_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B093_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B093_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B093_extra_packed) == 1, "");
_Static_assert(sizeof(struct B093_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B093_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B093_extra_size) == 6, "");
_Static_assert(_Alignof(struct B093_extra_size) == 1, "");
_Static_assert(sizeof(B094) == 4, "");
_Static_assert(_Alignof(B094) == 4, "");
_Static_assert(sizeof(struct B094_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B094_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B094_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B094_extra_packed) == 1, "");
_Static_assert(sizeof(struct B094_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B094_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B094_extra_size) == 6, "");
_Static_assert(_Alignof(struct B094_extra_size) == 1, "");
_Static_assert(sizeof(B095) == 4, "");
_Static_assert(_Alignof(B095) == 4, "");
_Static_assert(sizeof(struct B095_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B095_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B095_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B095_extra_packed) == 1, "");
_Static_assert(sizeof(struct B095_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B095_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B095_extra_size) == 6, "");
_Static_assert(_Alignof(struct B095_extra_size) == 1, "");
_Static_assert(sizeof(B096) == 4, "");
_Static_assert(_Alignof(B096) == 4, "");
_Static_assert(sizeof(struct B096_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B096_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B096_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B096_extra_packed) == 1, "");
_Static_assert(sizeof(struct B096_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B096_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B096_extra_size) == 6, "");
_Static_assert(_Alignof(struct B096_extra_size) == 1, "");
_Static_assert(sizeof(B101) == 4, "");
_Static_assert(_Alignof(B101) == 4, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 6, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
_Static_assert(sizeof(B102) == 4, "");
_Static_assert(_Alignof(B102) == 4, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 6, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 4, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 4, "");
_Static_assert(_Alignof(B105) == 4, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 6, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
_Static_assert(sizeof(B106) == 4, "");
_Static_assert(_Alignof(B106) == 4, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 6, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
_Static_assert(sizeof(B107) == 4, "");
_Static_assert(_Alignof(B107) == 4, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 6, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 4, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
_Static_assert(sizeof(B109) == 4, "");
_Static_assert(_Alignof(B109) == 4, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 6, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 4, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 4, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 4, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 4, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 4, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 4, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
_Static_assert(sizeof(B121) == 8, "");
_Static_assert(_Alignof(B121) == 4, "");
_Static_assert(sizeof(struct B121_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B121_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B121_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B121_extra_packed) == 1, "");
_Static_assert(sizeof(struct B121_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B121_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B121_extra_size) == 10, "");
_Static_assert(_Alignof(struct B121_extra_size) == 1, "");
_Static_assert(sizeof(B122) == 8, "");
_Static_assert(_Alignof(B122) == 4, "");
_Static_assert(sizeof(struct B122_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B122_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B122_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B122_extra_packed) == 1, "");
_Static_assert(sizeof(struct B122_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B122_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B122_extra_size) == 10, "");
_Static_assert(_Alignof(struct B122_extra_size) == 1, "");
_Static_assert(sizeof(B123) == 8, "");
_Static_assert(_Alignof(B123) == 4, "");
_Static_assert(sizeof(struct B123_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B123_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B123_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B123_extra_packed) == 1, "");
_Static_assert(sizeof(struct B123_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B123_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B123_extra_size) == 10, "");
_Static_assert(_Alignof(struct B123_extra_size) == 1, "");
_Static_assert(sizeof(B124) == 8, "");
_Static_assert(_Alignof(B124) == 4, "");
_Static_assert(sizeof(struct B124_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B124_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B124_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B124_extra_packed) == 1, "");
_Static_assert(sizeof(struct B124_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B124_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B124_extra_size) == 10, "");
_Static_assert(_Alignof(struct B124_extra_size) == 1, "");
_Static_assert(sizeof(B125) == 8, "");
_Static_assert(_Alignof(B125) == 4, "");
_Static_assert(sizeof(struct B125_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B125_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B125_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B125_extra_packed) == 1, "");
_Static_assert(sizeof(struct B125_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B125_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B125_extra_size) == 10, "");
_Static_assert(_Alignof(struct B125_extra_size) == 1, "");
_Static_assert(sizeof(B126) == 8, "");
_Static_assert(_Alignof(B126) == 4, "");
_Static_assert(sizeof(struct B126_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B126_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B126_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B126_extra_packed) == 1, "");
_Static_assert(sizeof(struct B126_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B126_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B126_extra_size) == 10, "");
_Static_assert(_Alignof(struct B126_extra_size) == 1, "");
_Static_assert(sizeof(B127) == 8, "");
_Static_assert(_Alignof(B127) == 4, "");
_Static_assert(sizeof(struct B127_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B127_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B127_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B127_extra_packed) == 1, "");
_Static_assert(sizeof(struct B127_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B127_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B127_extra_size) == 10, "");
_Static_assert(_Alignof(struct B127_extra_size) == 1, "");
_Static_assert(sizeof(B128) == 8, "");
_Static_assert(_Alignof(B128) == 4, "");
_Static_assert(sizeof(struct B128_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B128_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B128_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B128_extra_packed) == 1, "");
_Static_assert(sizeof(struct B128_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B128_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B128_extra_size) == 10, "");
_Static_assert(_Alignof(struct B128_extra_size) == 1, "");
_Static_assert(sizeof(B129) == 8, "");
_Static_assert(_Alignof(B129) == 4, "");
_Static_assert(sizeof(struct B129_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B129_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B129_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B129_extra_packed) == 1, "");
_Static_assert(sizeof(struct B129_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B129_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B129_extra_size) == 10, "");
_Static_assert(_Alignof(struct B129_extra_size) == 1, "");
_Static_assert(sizeof(B130) == 8, "");
_Static_assert(_Alignof(B130) == 4, "");
_Static_assert(sizeof(struct B130_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B130_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B130_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B130_extra_packed) == 1, "");
_Static_assert(sizeof(struct B130_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B130_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B130_extra_size) == 10, "");
_Static_assert(_Alignof(struct B130_extra_size) == 1, "");
_Static_assert(sizeof(B131) == 8, "");
_Static_assert(_Alignof(B131) == 4, "");
_Static_assert(sizeof(struct B131_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B131_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B131_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B131_extra_packed) == 1, "");
_Static_assert(sizeof(struct B131_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B131_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B131_extra_size) == 10, "");
_Static_assert(_Alignof(struct B131_extra_size) == 1, "");
_Static_assert(sizeof(B132) == 8, "");
_Static_assert(_Alignof(B132) == 4, "");
_Static_assert(sizeof(struct B132_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B132_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B132_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B132_extra_packed) == 1, "");
_Static_assert(sizeof(struct B132_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B132_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B132_extra_size) == 10, "");
_Static_assert(_Alignof(struct B132_extra_size) == 1, "");
_Static_assert(sizeof(B133) == 8, "");
_Static_assert(_Alignof(B133) == 4, "");
_Static_assert(sizeof(struct B133_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B133_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B133_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B133_extra_packed) == 1, "");
_Static_assert(sizeof(struct B133_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B133_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B133_extra_size) == 10, "");
_Static_assert(_Alignof(struct B133_extra_size) == 1, "");
_Static_assert(sizeof(B134) == 8, "");
_Static_assert(_Alignof(B134) == 4, "");
_Static_assert(sizeof(struct B134_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B134_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B134_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B134_extra_packed) == 1, "");
_Static_assert(sizeof(struct B134_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B134_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B134_extra_size) == 10, "");
_Static_assert(_Alignof(struct B134_extra_size) == 1, "");
_Static_assert(sizeof(B135) == 8, "");
_Static_assert(_Alignof(B135) == 4, "");
_Static_assert(sizeof(struct B135_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B135_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B135_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B135_extra_packed) == 1, "");
_Static_assert(sizeof(struct B135_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B135_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B135_extra_size) == 10, "");
_Static_assert(_Alignof(struct B135_extra_size) == 1, "");
_Static_assert(sizeof(B136) == 8, "");
_Static_assert(_Alignof(B136) == 4, "");
_Static_assert(sizeof(struct B136_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B136_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B136_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B136_extra_packed) == 1, "");
_Static_assert(sizeof(struct B136_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B136_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B136_extra_size) == 10, "");
_Static_assert(_Alignof(struct B136_extra_size) == 1, "");
_Static_assert(sizeof(B141) == 8, "");
_Static_assert(_Alignof(B141) == 4, "");
_Static_assert(sizeof(struct B141_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B141_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B141_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B141_extra_packed) == 1, "");
_Static_assert(sizeof(struct B141_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B141_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B141_extra_size) == 10, "");
_Static_assert(_Alignof(struct B141_extra_size) == 1, "");
_Static_assert(sizeof(B142) == 8, "");
_Static_assert(_Alignof(B142) == 4, "");
_Static_assert(sizeof(struct B142_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B142_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B142_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B142_extra_packed) == 1, "");
_Static_assert(sizeof(struct B142_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B142_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B142_extra_size) == 10, "");
_Static_assert(_Alignof(struct B142_extra_size) == 1, "");
_Static_assert(sizeof(B143) == 8, "");
_Static_assert(_Alignof(B143) == 4, "");
_Static_assert(sizeof(struct B143_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B143_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B143_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B143_extra_packed) == 1, "");
_Static_assert(sizeof(struct B143_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B143_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B143_extra_size) == 10, "");
_Static_assert(_Alignof(struct B143_extra_size) == 1, "");
_Static_assert(sizeof(B144) == 8, "");
_Static_assert(_Alignof(B144) == 4, "");
_Static_assert(sizeof(struct B144_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B144_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B144_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B144_extra_packed) == 1, "");
_Static_assert(sizeof(struct B144_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B144_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B144_extra_size) == 10, "");
_Static_assert(_Alignof(struct B144_extra_size) == 1, "");
_Static_assert(sizeof(B145) == 8, "");
_Static_assert(_Alignof(B145) == 4, "");
_Static_assert(sizeof(struct B145_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B145_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B145_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B145_extra_packed) == 1, "");
_Static_assert(sizeof(struct B145_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B145_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B145_extra_size) == 10, "");
_Static_assert(_Alignof(struct B145_extra_size) == 1, "");
_Static_assert(sizeof(B146) == 8, "");
_Static_assert(_Alignof(B146) == 4, "");
_Static_assert(sizeof(struct B146_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B146_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B146_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B146_extra_packed) == 1, "");
_Static_assert(sizeof(struct B146_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B146_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B146_extra_size) == 10, "");
_Static_assert(_Alignof(struct B146_extra_size) == 1, "");
_Static_assert(sizeof(B147) == 8, "");
_Static_assert(_Alignof(B147) == 4, "");
_Static_assert(sizeof(struct B147_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B147_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B147_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B147_extra_packed) == 1, "");
_Static_assert(sizeof(struct B147_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B147_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B147_extra_size) == 10, "");
_Static_assert(_Alignof(struct B147_extra_size) == 1, "");
_Static_assert(sizeof(B148) == 8, "");
_Static_assert(_Alignof(B148) == 4, "");
_Static_assert(sizeof(struct B148_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B148_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B148_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B148_extra_packed) == 1, "");
_Static_assert(sizeof(struct B148_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B148_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B148_extra_size) == 10, "");
_Static_assert(_Alignof(struct B148_extra_size) == 1, "");
_Static_assert(sizeof(B149) == 8, "");
_Static_assert(_Alignof(B149) == 4, "");
_Static_assert(sizeof(struct B149_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B149_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B149_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B149_extra_packed) == 1, "");
_Static_assert(sizeof(struct B149_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B149_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B149_extra_size) == 10, "");
_Static_assert(_Alignof(struct B149_extra_size) == 1, "");
_Static_assert(sizeof(B150) == 8, "");
_Static_assert(_Alignof(B150) == 4, "");
_Static_assert(sizeof(struct B150_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B150_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B150_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B150_extra_packed) == 1, "");
_Static_assert(sizeof(struct B150_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B150_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B150_extra_size) == 10, "");
_Static_assert(_Alignof(struct B150_extra_size) == 1, "");
_Static_assert(sizeof(B151) == 8, "");
_Static_assert(_Alignof(B151) == 4, "");
_Static_assert(sizeof(struct B151_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B151_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B151_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B151_extra_packed) == 1, "");
_Static_assert(sizeof(struct B151_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B151_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B151_extra_size) == 10, "");
_Static_assert(_Alignof(struct B151_extra_size) == 1, "");
_Static_assert(sizeof(B152) == 8, "");
_Static_assert(_Alignof(B152) == 4, "");
_Static_assert(sizeof(struct B152_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B152_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B152_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B152_extra_packed) == 1, "");
_Static_assert(sizeof(struct B152_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B152_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B152_extra_size) == 10, "");
_Static_assert(_Alignof(struct B152_extra_size) == 1, "");
_Static_assert(sizeof(B153) == 8, "");
_Static_assert(_Alignof(B153) == 4, "");
_Static_assert(sizeof(struct B153_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B153_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B153_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B153_extra_packed) == 1, "");
_Static_assert(sizeof(struct B153_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B153_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B153_extra_size) == 10, "");
_Static_assert(_Alignof(struct B153_extra_size) == 1, "");
_Static_assert(sizeof(B154) == 8, "");
_Static_assert(_Alignof(B154) == 4, "");
_Static_assert(sizeof(struct B154_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B154_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B154_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B154_extra_packed) == 1, "");
_Static_assert(sizeof(struct B154_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B154_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B154_extra_size) == 10, "");
_Static_assert(_Alignof(struct B154_extra_size) == 1, "");
_Static_assert(sizeof(B155) == 8, "");
_Static_assert(_Alignof(B155) == 4, "");
_Static_assert(sizeof(struct B155_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B155_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B155_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B155_extra_packed) == 1, "");
_Static_assert(sizeof(struct B155_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B155_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B155_extra_size) == 10, "");
_Static_assert(_Alignof(struct B155_extra_size) == 1, "");
_Static_assert(sizeof(B156) == 8, "");
_Static_assert(_Alignof(B156) == 4, "");
_Static_assert(sizeof(struct B156_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B156_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B156_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B156_extra_packed) == 1, "");
_Static_assert(sizeof(struct B156_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B156_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B156_extra_size) == 10, "");
_Static_assert(_Alignof(struct B156_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A000) == 1, "");
_Static_assert(_Alignof(A000) == 1, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 3, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
_Static_assert(sizeof(A001) == 1, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 3, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
_Static_assert(sizeof(A002) == 1, "");
_Static_assert(_Alignof(A002) == 1, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 3, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
_Static_assert(sizeof(A003) == 1, "");
_Static_assert(_Alignof(A003) == 1, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 3, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
_Static_assert(sizeof(A004) == 1, "");
_Static_assert(_Alignof(A004) == 1, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 3, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 1, "");
_Static_assert(_Alignof(A005) == 1, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 3, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
_Static_assert(sizeof(A006) == 1, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 3, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
_Static_assert(sizeof(A007) == 1, "");
_Static_assert(_Alignof(A007) == 1, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 3, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
_Static_assert(sizeof(A008) == 1, "");
_Static_assert(_Alignof(A008) == 1, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 3, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
_Static_assert(sizeof(A009) == 2, "");
_Static_assert(_Alignof(A009) == 1, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 4, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
_Static_assert(sizeof(A010) == 2, "");
_Static_assert(_Alignof(A010) == 1, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 4, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
_Static_assert(sizeof(A011) == 2, "");
_Static_assert(_Alignof(A011) == 1, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 4, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
_Static_assert(sizeof(A012) == 2, "");
_Static_assert(_Alignof(A012) == 1, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 4, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
_Static_assert(sizeof(A013) == 2, "");
_Static_assert(_Alignof(A013) == 1, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 4, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
_Static_assert(sizeof(A014) == 2, "");
_Static_assert(_Alignof(A014) == 1, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 4, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
_Static_assert(sizeof(A015) == 2, "");
_Static_assert(_Alignof(A015) == 1, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 4, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
_Static_assert(sizeof(A016) == 2, "");
_Static_assert(_Alignof(A016) == 1, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 4, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
_Static_assert(sizeof(A021) == 4, "");
_Static_assert(_Alignof(A021) == 1, "");
_Static_assert(sizeof(struct A021_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A021_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A021_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A021_extra_packed) == 1, "");
_Static_assert(sizeof(struct A021_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A021_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A021_extra_size) == 6, "");
_Static_assert(_Alignof(struct A021_extra_size) == 1, "");
_Static_assert(sizeof(A022) == 4, "");
_Static_assert(_Alignof(A022) == 1, "");
_Static_assert(sizeof(struct A022_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A022_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A022_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A022_extra_packed) == 1, "");
_Static_assert(sizeof(struct A022_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A022_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A022_extra_size) == 6, "");
_Static_assert(_Alignof(struct A022_extra_size) == 1, "");
_Static_assert(sizeof(A023) == 4, "");
_Static_assert(_Alignof(A023) == 1, "");
_Static_assert(sizeof(struct A023_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A023_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A023_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A023_extra_packed) == 1, "");
_Static_assert(sizeof(struct A023_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A023_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A023_extra_size) == 6, "");
_Static_assert(_Alignof(struct A023_extra_size) == 1, "");
_Static_assert(sizeof(A024) == 4, "");
_Static_assert(_Alignof(A024) == 1, "");
_Static_assert(sizeof(struct A024_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A024_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A024_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A024_extra_packed) == 1, "");
_Static_assert(sizeof(struct A024_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A024_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A024_extra_size) == 6, "");
_Static_assert(_Alignof(struct A024_extra_size) == 1, "");
_Static_assert(sizeof(A025) == 4, "");
_Static_assert(_Alignof(A025) == 1, "");
_Static_assert(sizeof(struct A025_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A025_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A025_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A025_extra_packed) == 1, "");
_Static_assert(sizeof(struct A025_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A025_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A025_extra_size) == 6, "");
_Static_assert(_Alignof(struct A025_extra_size) == 1, "");
_Static_assert(sizeof(A026) == 4, "");
_Static_assert(_Alignof(A026) == 1, "");
_Static_assert(sizeof(struct A026_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A026_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A026_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A026_extra_packed) == 1, "");
_Static_assert(sizeof(struct A026_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A026_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A026_extra_size) == 6, "");
_Static_assert(_Alignof(struct A026_extra_size) == 1, "");
_Static_assert(sizeof(A027) == 4, "");
_Static_assert(_Alignof(A027) == 1, "");
_Static_assert(sizeof(struct A027_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A027_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A027_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A027_extra_packed) == 1, "");
_Static_assert(sizeof(struct A027_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A027_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A027_extra_size) == 6, "");
_Static_assert(_Alignof(struct A027_extra_size) == 1, "");
_Static_assert(sizeof(A028) == 4, "");
_Static_assert(_Alignof(A028) == 1, "");
_Static_assert(sizeof(struct A028_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A028_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A028_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A028_extra_packed) == 1, "");
_Static_assert(sizeof(struct A028_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A028_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A028_extra_size) == 6, "");
_Static_assert(_Alignof(struct A028_extra_size) == 1, "");
_Static_assert(sizeof(A029) == 4, "");
_Static_assert(_Alignof(A029) == 1, "");
_Static_assert(sizeof(struct A029_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A029_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A029_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A029_extra_packed) == 1, "");
_Static_assert(sizeof(struct A029_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A029_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A029_extra_size) == 6, "");
_Static_assert(_Alignof(struct A029_extra_size) == 1, "");
_Static_assert(sizeof(A030) == 4, "");
_Static_assert(_Alignof(A030) == 1, "");
_Static_assert(sizeof(struct A030_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A030_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A030_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A030_extra_packed) == 1, "");
_Static_assert(sizeof(struct A030_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A030_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A030_extra_size) == 6, "");
_Static_assert(_Alignof(struct A030_extra_size) == 1, "");
_Static_assert(sizeof(A031) == 4, "");
_Static_assert(_Alignof(A031) == 1, "");
_Static_assert(sizeof(struct A031_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A031_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A031_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A031_extra_packed) == 1, "");
_Static_assert(sizeof(struct A031_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A031_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A031_extra_size) == 6, "");
_Static_assert(_Alignof(struct A031_extra_size) == 1, "");
_Static_assert(sizeof(A032) == 4, "");
_Static_assert(_Alignof(A032) == 1, "");
_Static_assert(sizeof(struct A032_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A032_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A032_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A032_extra_packed) == 1, "");
_Static_assert(sizeof(struct A032_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A032_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A032_extra_size) == 6, "");
_Static_assert(_Alignof(struct A032_extra_size) == 1, "");
_Static_assert(sizeof(A033) == 4, "");
_Static_assert(_Alignof(A033) == 1, "");
_Static_assert(sizeof(struct A033_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A033_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A033_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A033_extra_packed) == 1, "");
_Static_assert(sizeof(struct A033_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A033_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A033_extra_size) == 6, "");
_Static_assert(_Alignof(struct A033_extra_size) == 1, "");
_Static_assert(sizeof(A034) == 4, "");
_Static_assert(_Alignof(A034) == 1, "");
_Static_assert(sizeof(struct A034_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A034_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A034_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A034_extra_packed) == 1, "");
_Static_assert(sizeof(struct A034_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A034_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A034_extra_size) == 6, "");
_Static_assert(_Alignof(struct A034_extra_size) == 1, "");
_Static_assert(sizeof(A035) == 4, "");
_Static_assert(_Alignof(A035) == 1, "");
_Static_assert(sizeof(struct A035_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A035_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A035_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A035_extra_packed) == 1, "");
_Static_assert(sizeof(struct A035_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A035_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A035_extra_size) == 6, "");
_Static_assert(_Alignof(struct A035_extra_size) == 1, "");
_Static_assert(sizeof(A036) == 4, "");
_Static_assert(_Alignof(A036) == 1, "");
_Static_assert(sizeof(struct A036_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A036_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A036_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A036_extra_packed) == 1, "");
_Static_assert(sizeof(struct A036_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A036_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A036_extra_size) == 6, "");
_Static_assert(_Alignof(struct A036_extra_size) == 1, "");
_Static_assert(sizeof(A041) == 8, "");
_Static_assert(_Alignof(A041) == 1, "");
_Static_assert(sizeof(struct A041_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A041_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A041_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A041_extra_packed) == 1, "");
_Static_assert(sizeof(struct A041_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A041_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A041_extra_size) == 10, "");
_Static_assert(_Alignof(struct A041_extra_size) == 1, "");
_Static_assert(sizeof(A042) == 8, "");
_Static_assert(_Alignof(A042) == 1, "");
_Static_assert(sizeof(struct A042_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A042_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A042_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A042_extra_packed) == 1, "");
_Static_assert(sizeof(struct A042_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A042_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A042_extra_size) == 10, "");
_Static_assert(_Alignof(struct A042_extra_size) == 1, "");
_Static_assert(sizeof(A043) == 8, "");
_Static_assert(_Alignof(A043) == 1, "");
_Static_assert(sizeof(struct A043_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A043_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A043_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A043_extra_packed) == 1, "");
_Static_assert(sizeof(struct A043_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A043_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A043_extra_size) == 10, "");
_Static_assert(_Alignof(struct A043_extra_size) == 1, "");
_Static_assert(sizeof(A044) == 8, "");
_Static_assert(_Alignof(A044) == 1, "");
_Static_assert(sizeof(struct A044_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A044_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A044_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A044_extra_packed) == 1, "");
_Static_assert(sizeof(struct A044_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A044_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A044_extra_size) == 10, "");
_Static_assert(_Alignof(struct A044_extra_size) == 1, "");
_Static_assert(sizeof(A045) == 8, "");
_Static_assert(_Alignof(A045) == 1, "");
_Static_assert(sizeof(struct A045_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A045_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A045_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A045_extra_packed) == 1, "");
_Static_assert(sizeof(struct A045_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A045_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A045_extra_size) == 10, "");
_Static_assert(_Alignof(struct A045_extra_size) == 1, "");
_Static_assert(sizeof(A046) == 8, "");
_Static_assert(_Alignof(A046) == 1, "");
_Static_assert(sizeof(struct A046_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A046_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A046_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A046_extra_packed) == 1, "");
_Static_assert(sizeof(struct A046_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A046_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A046_extra_size) == 10, "");
_Static_assert(_Alignof(struct A046_extra_size) == 1, "");
_Static_assert(sizeof(A047) == 8, "");
_Static_assert(_Alignof(A047) == 1, "");
_Static_assert(sizeof(struct A047_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A047_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A047_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A047_extra_packed) == 1, "");
_Static_assert(sizeof(struct A047_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A047_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A047_extra_size) == 10, "");
_Static_assert(_Alignof(struct A047_extra_size) == 1, "");
_Static_assert(sizeof(A048) == 8, "");
_Static_assert(_Alignof(A048) == 1, "");
_Static_assert(sizeof(struct A048_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A048_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A048_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A048_extra_packed) == 1, "");
_Static_assert(sizeof(struct A048_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A048_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A048_extra_size) == 10, "");
_Static_assert(_Alignof(struct A048_extra_size) == 1, "");
_Static_assert(sizeof(A049) == 8, "");
_Static_assert(_Alignof(A049) == 1, "");
_Static_assert(sizeof(struct A049_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A049_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A049_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A049_extra_packed) == 1, "");
_Static_assert(sizeof(struct A049_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A049_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A049_extra_size) == 10, "");
_Static_assert(_Alignof(struct A049_extra_size) == 1, "");
_Static_assert(sizeof(A050) == 8, "");
_Static_assert(_Alignof(A050) == 1, "");
_Static_assert(sizeof(struct A050_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A050_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A050_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A050_extra_packed) == 1, "");
_Static_assert(sizeof(struct A050_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A050_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A050_extra_size) == 10, "");
_Static_assert(_Alignof(struct A050_extra_size) == 1, "");
_Static_assert(sizeof(A051) == 8, "");
_Static_assert(_Alignof(A051) == 1, "");
_Static_assert(sizeof(struct A051_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A051_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A051_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A051_extra_packed) == 1, "");
_Static_assert(sizeof(struct A051_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A051_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A051_extra_size) == 10, "");
_Static_assert(_Alignof(struct A051_extra_size) == 1, "");
_Static_assert(sizeof(A052) == 8, "");
_Static_assert(_Alignof(A052) == 1, "");
_Static_assert(sizeof(struct A052_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A052_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A052_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A052_extra_packed) == 1, "");
_Static_assert(sizeof(struct A052_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A052_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A052_extra_size) == 10, "");
_Static_assert(_Alignof(struct A052_extra_size) == 1, "");
_Static_assert(sizeof(A053) == 8, "");
_Static_assert(_Alignof(A053) == 1, "");
_Static_assert(sizeof(struct A053_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A053_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A053_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A053_extra_packed) == 1, "");
_Static_assert(sizeof(struct A053_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A053_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A053_extra_size) == 10, "");
_Static_assert(_Alignof(struct A053_extra_size) == 1, "");
_Static_assert(sizeof(A054) == 8, "");
_Static_assert(_Alignof(A054) == 1, "");
_Static_assert(sizeof(struct A054_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A054_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A054_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A054_extra_packed) == 1, "");
_Static_assert(sizeof(struct A054_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A054_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A054_extra_size) == 10, "");
_Static_assert(_Alignof(struct A054_extra_size) == 1, "");
_Static_assert(sizeof(A055) == 8, "");
_Static_assert(_Alignof(A055) == 1, "");
_Static_assert(sizeof(struct A055_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A055_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A055_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A055_extra_packed) == 1, "");
_Static_assert(sizeof(struct A055_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A055_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A055_extra_size) == 10, "");
_Static_assert(_Alignof(struct A055_extra_size) == 1, "");
_Static_assert(sizeof(A056) == 8, "");
_Static_assert(_Alignof(A056) == 1, "");
_Static_assert(sizeof(struct A056_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A056_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A056_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A056_extra_packed) == 1, "");
_Static_assert(sizeof(struct A056_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A056_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A056_extra_size) == 10, "");
_Static_assert(_Alignof(struct A056_extra_size) == 1, "");
_Static_assert(sizeof(A061) == 8, "");
_Static_assert(_Alignof(A061) == 1, "");
_Static_assert(sizeof(struct A061_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A061_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A061_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A061_extra_packed) == 1, "");
_Static_assert(sizeof(struct A061_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A061_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A061_extra_size) == 10, "");
_Static_assert(_Alignof(struct A061_extra_size) == 1, "");
_Static_assert(sizeof(A062) == 8, "");
_Static_assert(_Alignof(A062) == 1, "");
_Static_assert(sizeof(struct A062_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A062_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A062_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A062_extra_packed) == 1, "");
_Static_assert(sizeof(struct A062_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A062_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A062_extra_size) == 10, "");
_Static_assert(_Alignof(struct A062_extra_size) == 1, "");
_Static_assert(sizeof(A063) == 8, "");
_Static_assert(_Alignof(A063) == 1, "");
_Static_assert(sizeof(struct A063_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A063_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A063_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A063_extra_packed) == 1, "");
_Static_assert(sizeof(struct A063_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A063_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A063_extra_size) == 10, "");
_Static_assert(_Alignof(struct A063_extra_size) == 1, "");
_Static_assert(sizeof(A064) == 8, "");
_Static_assert(_Alignof(A064) == 1, "");
_Static_assert(sizeof(struct A064_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A064_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A064_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A064_extra_packed) == 1, "");
_Static_assert(sizeof(struct A064_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A064_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A064_extra_size) == 10, "");
_Static_assert(_Alignof(struct A064_extra_size) == 1, "");
_Static_assert(sizeof(A065) == 8, "");
_Static_assert(_Alignof(A065) == 1, "");
_Static_assert(sizeof(struct A065_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A065_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A065_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A065_extra_packed) == 1, "");
_Static_assert(sizeof(struct A065_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A065_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A065_extra_size) == 10, "");
_Static_assert(_Alignof(struct A065_extra_size) == 1, "");
_Static_assert(sizeof(A066) == 8, "");
_Static_assert(_Alignof(A066) == 1, "");
_Static_assert(sizeof(struct A066_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A066_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A066_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A066_extra_packed) == 1, "");
_Static_assert(sizeof(struct A066_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A066_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A066_extra_size) == 10, "");
_Static_assert(_Alignof(struct A066_extra_size) == 1, "");
_Static_assert(sizeof(A067) == 8, "");
_Static_assert(_Alignof(A067) == 1, "");
_Static_assert(sizeof(struct A067_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A067_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A067_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A067_extra_packed) == 1, "");
_Static_assert(sizeof(struct A067_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A067_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A067_extra_size) == 10, "");
_Static_assert(_Alignof(struct A067_extra_size) == 1, "");
_Static_assert(sizeof(A068) == 8, "");
_Static_assert(_Alignof(A068) == 1, "");
_Static_assert(sizeof(struct A068_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A068_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A068_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A068_extra_packed) == 1, "");
_Static_assert(sizeof(struct A068_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A068_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A068_extra_size) == 10, "");
_Static_assert(_Alignof(struct A068_extra_size) == 1, "");
_Static_assert(sizeof(A069) == 8, "");
_Static_assert(_Alignof(A069) == 1, "");
_Static_assert(sizeof(struct A069_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A069_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A069_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A069_extra_packed) == 1, "");
_Static_assert(sizeof(struct A069_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A069_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A069_extra_size) == 10, "");
_Static_assert(_Alignof(struct A069_extra_size) == 1, "");
_Static_assert(sizeof(A070) == 8, "");
_Static_assert(_Alignof(A070) == 1, "");
_Static_assert(sizeof(struct A070_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A070_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A070_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A070_extra_packed) == 1, "");
_Static_assert(sizeof(struct A070_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A070_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A070_extra_size) == 10, "");
_Static_assert(_Alignof(struct A070_extra_size) == 1, "");
_Static_assert(sizeof(A071) == 8, "");
_Static_assert(_Alignof(A071) == 1, "");
_Static_assert(sizeof(struct A071_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A071_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A071_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A071_extra_packed) == 1, "");
_Static_assert(sizeof(struct A071_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A071_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A071_extra_size) == 10, "");
_Static_assert(_Alignof(struct A071_extra_size) == 1, "");
_Static_assert(sizeof(A072) == 8, "");
_Static_assert(_Alignof(A072) == 1, "");
_Static_assert(sizeof(struct A072_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A072_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A072_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A072_extra_packed) == 1, "");
_Static_assert(sizeof(struct A072_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A072_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A072_extra_size) == 10, "");
_Static_assert(_Alignof(struct A072_extra_size) == 1, "");
_Static_assert(sizeof(A073) == 8, "");
_Static_assert(_Alignof(A073) == 1, "");
_Static_assert(sizeof(struct A073_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A073_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A073_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A073_extra_packed) == 1, "");
_Static_assert(sizeof(struct A073_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A073_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A073_extra_size) == 10, "");
_Static_assert(_Alignof(struct A073_extra_size) == 1, "");
_Static_assert(sizeof(A074) == 8, "");
_Static_assert(_Alignof(A074) == 1, "");
_Static_assert(sizeof(struct A074_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A074_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A074_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A074_extra_packed) == 1, "");
_Static_assert(sizeof(struct A074_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A074_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A074_extra_size) == 10, "");
_Static_assert(_Alignof(struct A074_extra_size) == 1, "");
_Static_assert(sizeof(A075) == 8, "");
_Static_assert(_Alignof(A075) == 1, "");
_Static_assert(sizeof(struct A075_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A075_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A075_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A075_extra_packed) == 1, "");
_Static_assert(sizeof(struct A075_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A075_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A075_extra_size) == 10, "");
_Static_assert(_Alignof(struct A075_extra_size) == 1, "");
_Static_assert(sizeof(A076) == 8, "");
_Static_assert(_Alignof(A076) == 1, "");
_Static_assert(sizeof(struct A076_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A076_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A076_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A076_extra_packed) == 1, "");
_Static_assert(sizeof(struct A076_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A076_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A076_extra_size) == 10, "");
_Static_assert(_Alignof(struct A076_extra_size) == 1, "");
_Static_assert(sizeof(A081) == 1, "");
_Static_assert(_Alignof(A081) == 1, "");
_Static_assert(sizeof(struct A081_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A081_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A081_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A081_extra_packed) == 1, "");
_Static_assert(sizeof(struct A081_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A081_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A081_extra_size) == 3, "");
_Static_assert(_Alignof(struct A081_extra_size) == 1, "");
_Static_assert(sizeof(A082) == 1, "");
_Static_assert(_Alignof(A082) == 1, "");
_Static_assert(sizeof(struct A082_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A082_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A082_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A082_extra_packed) == 1, "");
_Static_assert(sizeof(struct A082_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A082_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A082_extra_size) == 3, "");
_Static_assert(_Alignof(struct A082_extra_size) == 1, "");
_Static_assert(sizeof(A083) == 1, "");
_Static_assert(_Alignof(A083) == 1, "");
_Static_assert(sizeof(struct A083_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A083_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A083_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A083_extra_packed) == 1, "");
_Static_assert(sizeof(struct A083_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A083_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A083_extra_size) == 3, "");
_Static_assert(_Alignof(struct A083_extra_size) == 1, "");
_Static_assert(sizeof(A084) == 1, "");
_Static_assert(_Alignof(A084) == 1, "");
_Static_assert(sizeof(struct A084_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A084_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A084_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A084_extra_packed) == 1, "");
_Static_assert(sizeof(struct A084_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A084_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A084_extra_size) == 3, "");
_Static_assert(_Alignof(struct A084_extra_size) == 1, "");
_Static_assert(sizeof(A085) == 1, "");
_Static_assert(_Alignof(A085) == 1, "");
_Static_assert(sizeof(struct A085_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A085_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A085_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A085_extra_packed) == 1, "");
_Static_assert(sizeof(struct A085_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A085_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A085_extra_size) == 3, "");
_Static_assert(_Alignof(struct A085_extra_size) == 1, "");
_Static_assert(sizeof(A086) == 1, "");
_Static_assert(_Alignof(A086) == 1, "");
_Static_assert(sizeof(struct A086_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A086_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A086_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A086_extra_packed) == 1, "");
_Static_assert(sizeof(struct A086_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A086_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A086_extra_size) == 3, "");
_Static_assert(_Alignof(struct A086_extra_size) == 1, "");
_Static_assert(sizeof(A087) == 1, "");
_Static_assert(_Alignof(A087) == 1, "");
_Static_assert(sizeof(struct A087_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A087_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A087_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A087_extra_packed) == 1, "");
_Static_assert(sizeof(struct A087_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A087_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A087_extra_size) == 3, "");
_Static_assert(_Alignof(struct A087_extra_size) == 1, "");
_Static_assert(sizeof(A088) == 1, "");
_Static_assert(_Alignof(A088) == 1, "");
_Static_assert(sizeof(struct A088_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A088_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A088_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A088_extra_packed) == 1, "");
_Static_assert(sizeof(struct A088_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A088_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A088_extra_size) == 3, "");
_Static_assert(_Alignof(struct A088_extra_size) == 1, "");
_Static_assert(sizeof(A089) == 2, "");
_Static_assert(_Alignof(A089) == 1, "");
_Static_assert(sizeof(struct A089_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A089_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A089_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A089_extra_packed) == 1, "");
_Static_assert(sizeof(struct A089_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A089_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A089_extra_size) == 4, "");
_Static_assert(_Alignof(struct A089_extra_size) == 1, "");
_Static_assert(sizeof(A090) == 2, "");
_Static_assert(_Alignof(A090) == 1, "");
_Static_assert(sizeof(struct A090_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A090_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A090_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A090_extra_packed) == 1, "");
_Static_assert(sizeof(struct A090_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A090_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A090_extra_size) == 4, "");
_Static_assert(_Alignof(struct A090_extra_size) == 1, "");
_Static_assert(sizeof(A091) == 2, "");
_Static_assert(_Alignof(A091) == 1, "");
_Static_assert(sizeof(struct A091_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A091_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A091_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A091_extra_packed) == 1, "");
_Static_assert(sizeof(struct A091_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A091_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A091_extra_size) == 4, "");
_Static_assert(_Alignof(struct A091_extra_size) == 1, "");
_Static_assert(sizeof(A092) == 2, "");
_Static_assert(_Alignof(A092) == 1, "");
_Static_assert(sizeof(struct A092_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A092_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A092_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A092_extra_packed) == 1, "");
_Static_assert(sizeof(struct A092_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A092_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A092_extra_size) == 4, "");
_Static_assert(_Alignof(struct A092_extra_size) == 1, "");
_Static_assert(sizeof(A093) == 2, "");
_Static_assert(_Alignof(A093) == 1, "");
_Static_assert(sizeof(struct A093_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A093_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A093_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A093_extra_packed) == 1, "");
_Static_assert(sizeof(struct A093_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A093_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A093_extra_size) == 4, "");
_Static_assert(_Alignof(struct A093_extra_size) == 1, "");
_Static_assert(sizeof(A094) == 2, "");
_Static_assert(_Alignof(A094) == 1, "");
_Static_assert(sizeof(struct A094_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A094_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A094_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A094_extra_packed) == 1, "");
_Static_assert(sizeof(struct A094_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A094_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A094_extra_size) == 4, "");
_Static_assert(_Alignof(struct A094_extra_size) == 1, "");
_Static_assert(sizeof(A095) == 2, "");
_Static_assert(_Alignof(A095) == 1, "");
_Static_assert(sizeof(struct A095_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A095_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A095_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A095_extra_packed) == 1, "");
_Static_assert(sizeof(struct A095_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A095_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A095_extra_size) == 4, "");
_Static_assert(_Alignof(struct A095_extra_size) == 1, "");
_Static_assert(sizeof(A096) == 2, "");
_Static_assert(_Alignof(A096) == 1, "");
_Static_assert(sizeof(struct A096_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A096_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A096_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A096_extra_packed) == 1, "");
_Static_assert(sizeof(struct A096_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A096_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A096_extra_size) == 4, "");
_Static_assert(_Alignof(struct A096_extra_size) == 1, "");
_Static_assert(sizeof(A101) == 4, "");
_Static_assert(_Alignof(A101) == 1, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 6, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
_Static_assert(sizeof(A102) == 4, "");
_Static_assert(_Alignof(A102) == 1, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 6, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
_Static_assert(sizeof(A103) == 4, "");
_Static_assert(_Alignof(A103) == 1, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 6, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
_Static_assert(sizeof(A104) == 4, "");
_Static_assert(_Alignof(A104) == 1, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 6, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 1, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
_Static_assert(sizeof(A106) == 4, "");
_Static_assert(_Alignof(A106) == 1, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 6, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
_Static_assert(sizeof(A107) == 4, "");
_Static_assert(_Alignof(A107) == 1, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 6, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
_Static_assert(sizeof(A108) == 4, "");
_Static_assert(_Alignof(A108) == 1, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 6, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
_Static_assert(sizeof(A109) == 4, "");
_Static_assert(_Alignof(A109) == 1, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 6, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
_Static_assert(sizeof(A110) == 4, "");
_Static_assert(_Alignof(A110) == 1, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 6, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
_Static_assert(sizeof(A111) == 4, "");
_Static_assert(_Alignof(A111) == 1, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 6, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
_Static_assert(sizeof(A112) == 4, "");
_Static_assert(_Alignof(A112) == 1, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 6, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
_Static_assert(sizeof(A113) == 4, "");
_Static_assert(_Alignof(A113) == 1, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 6, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
_Static_assert(sizeof(A114) == 4, "");
_Static_assert(_Alignof(A114) == 1, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 6, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
_Static_assert(sizeof(A115) == 4, "");
_Static_assert(_Alignof(A115) == 1, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 6, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
_Static_assert(sizeof(A116) == 4, "");
_Static_assert(_Alignof(A116) == 1, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 6, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
_Static_assert(sizeof(A121) == 8, "");
_Static_assert(_Alignof(A121) == 1, "");
_Static_assert(sizeof(struct A121_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A121_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A121_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A121_extra_packed) == 1, "");
_Static_assert(sizeof(struct A121_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A121_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A121_extra_size) == 10, "");
_Static_assert(_Alignof(struct A121_extra_size) == 1, "");
_Static_assert(sizeof(A122) == 8, "");
_Static_assert(_Alignof(A122) == 1, "");
_Static_assert(sizeof(struct A122_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A122_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A122_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A122_extra_packed) == 1, "");
_Static_assert(sizeof(struct A122_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A122_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A122_extra_size) == 10, "");
_Static_assert(_Alignof(struct A122_extra_size) == 1, "");
_Static_assert(sizeof(A123) == 8, "");
_Static_assert(_Alignof(A123) == 1, "");
_Static_assert(sizeof(struct A123_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A123_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A123_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A123_extra_packed) == 1, "");
_Static_assert(sizeof(struct A123_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A123_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A123_extra_size) == 10, "");
_Static_assert(_Alignof(struct A123_extra_size) == 1, "");
_Static_assert(sizeof(A124) == 8, "");
_Static_assert(_Alignof(A124) == 1, "");
_Static_assert(sizeof(struct A124_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A124_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A124_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A124_extra_packed) == 1, "");
_Static_assert(sizeof(struct A124_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A124_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A124_extra_size) == 10, "");
_Static_assert(_Alignof(struct A124_extra_size) == 1, "");
_Static_assert(sizeof(A125) == 8, "");
_Static_assert(_Alignof(A125) == 1, "");
_Static_assert(sizeof(struct A125_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A125_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A125_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A125_extra_packed) == 1, "");
_Static_assert(sizeof(struct A125_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A125_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A125_extra_size) == 10, "");
_Static_assert(_Alignof(struct A125_extra_size) == 1, "");
_Static_assert(sizeof(A126) == 8, "");
_Static_assert(_Alignof(A126) == 1, "");
_Static_assert(sizeof(struct A126_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A126_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A126_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A126_extra_packed) == 1, "");
_Static_assert(sizeof(struct A126_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A126_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A126_extra_size) == 10, "");
_Static_assert(_Alignof(struct A126_extra_size) == 1, "");
_Static_assert(sizeof(A127) == 8, "");
_Static_assert(_Alignof(A127) == 1, "");
_Static_assert(sizeof(struct A127_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A127_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A127_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A127_extra_packed) == 1, "");
_Static_assert(sizeof(struct A127_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A127_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A127_extra_size) == 10, "");
_Static_assert(_Alignof(struct A127_extra_size) == 1, "");
_Static_assert(sizeof(A128) == 8, "");
_Static_assert(_Alignof(A128) == 1, "");
_Static_assert(sizeof(struct A128_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A128_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A128_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A128_extra_packed) == 1, "");
_Static_assert(sizeof(struct A128_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A128_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A128_extra_size) == 10, "");
_Static_assert(_Alignof(struct A128_extra_size) == 1, "");
_Static_assert(sizeof(A129) == 8, "");
_Static_assert(_Alignof(A129) == 1, "");
_Static_assert(sizeof(struct A129_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A129_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A129_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A129_extra_packed) == 1, "");
_Static_assert(sizeof(struct A129_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A129_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A129_extra_size) == 10, "");
_Static_assert(_Alignof(struct A129_extra_size) == 1, "");
_Static_assert(sizeof(A130) == 8, "");
_Static_assert(_Alignof(A130) == 1, "");
_Static_assert(sizeof(struct A130_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A130_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A130_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A130_extra_packed) == 1, "");
_Static_assert(sizeof(struct A130_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A130_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A130_extra_size) == 10, "");
_Static_assert(_Alignof(struct A130_extra_size) == 1, "");
_Static_assert(sizeof(A131) == 8, "");
_Static_assert(_Alignof(A131) == 1, "");
_Static_assert(sizeof(struct A131_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A131_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A131_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A131_extra_packed) == 1, "");
_Static_assert(sizeof(struct A131_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A131_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A131_extra_size) == 10, "");
_Static_assert(_Alignof(struct A131_extra_size) == 1, "");
_Static_assert(sizeof(A132) == 8, "");
_Static_assert(_Alignof(A132) == 1, "");
_Static_assert(sizeof(struct A132_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A132_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A132_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A132_extra_packed) == 1, "");
_Static_assert(sizeof(struct A132_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A132_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A132_extra_size) == 10, "");
_Static_assert(_Alignof(struct A132_extra_size) == 1, "");
_Static_assert(sizeof(A133) == 8, "");
_Static_assert(_Alignof(A133) == 1, "");
_Static_assert(sizeof(struct A133_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A133_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A133_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A133_extra_packed) == 1, "");
_Static_assert(sizeof(struct A133_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A133_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A133_extra_size) == 10, "");
_Static_assert(_Alignof(struct A133_extra_size) == 1, "");
_Static_assert(sizeof(A134) == 8, "");
_Static_assert(_Alignof(A134) == 1, "");
_Static_assert(sizeof(struct A134_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A134_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A134_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A134_extra_packed) == 1, "");
_Static_assert(sizeof(struct A134_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A134_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A134_extra_size) == 10, "");
_Static_assert(_Alignof(struct A134_extra_size) == 1, "");
_Static_assert(sizeof(A135) == 8, "");
_Static_assert(_Alignof(A135) == 1, "");
_Static_assert(sizeof(struct A135_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A135_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A135_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A135_extra_packed) == 1, "");
_Static_assert(sizeof(struct A135_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A135_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A135_extra_size) == 10, "");
_Static_assert(_Alignof(struct A135_extra_size) == 1, "");
_Static_assert(sizeof(A136) == 8, "");
_Static_assert(_Alignof(A136) == 1, "");
_Static_assert(sizeof(struct A136_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A136_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A136_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A136_extra_packed) == 1, "");
_Static_assert(sizeof(struct A136_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A136_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A136_extra_size) == 10, "");
_Static_assert(_Alignof(struct A136_extra_size) == 1, "");
_Static_assert(sizeof(A141) == 8, "");
_Static_assert(_Alignof(A141) == 1, "");
_Static_assert(sizeof(struct A141_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A141_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A141_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A141_extra_packed) == 1, "");
_Static_assert(sizeof(struct A141_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A141_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A141_extra_size) == 10, "");
_Static_assert(_Alignof(struct A141_extra_size) == 1, "");
_Static_assert(sizeof(A142) == 8, "");
_Static_assert(_Alignof(A142) == 1, "");
_Static_assert(sizeof(struct A142_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A142_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A142_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A142_extra_packed) == 1, "");
_Static_assert(sizeof(struct A142_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A142_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A142_extra_size) == 10, "");
_Static_assert(_Alignof(struct A142_extra_size) == 1, "");
_Static_assert(sizeof(A143) == 8, "");
_Static_assert(_Alignof(A143) == 1, "");
_Static_assert(sizeof(struct A143_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A143_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A143_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A143_extra_packed) == 1, "");
_Static_assert(sizeof(struct A143_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A143_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A143_extra_size) == 10, "");
_Static_assert(_Alignof(struct A143_extra_size) == 1, "");
_Static_assert(sizeof(A144) == 8, "");
_Static_assert(_Alignof(A144) == 1, "");
_Static_assert(sizeof(struct A144_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A144_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A144_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A144_extra_packed) == 1, "");
_Static_assert(sizeof(struct A144_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A144_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A144_extra_size) == 10, "");
_Static_assert(_Alignof(struct A144_extra_size) == 1, "");
_Static_assert(sizeof(A145) == 8, "");
_Static_assert(_Alignof(A145) == 1, "");
_Static_assert(sizeof(struct A145_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A145_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A145_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A145_extra_packed) == 1, "");
_Static_assert(sizeof(struct A145_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A145_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A145_extra_size) == 10, "");
_Static_assert(_Alignof(struct A145_extra_size) == 1, "");
_Static_assert(sizeof(A146) == 8, "");
_Static_assert(_Alignof(A146) == 1, "");
_Static_assert(sizeof(struct A146_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A146_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A146_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A146_extra_packed) == 1, "");
_Static_assert(sizeof(struct A146_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A146_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A146_extra_size) == 10, "");
_Static_assert(_Alignof(struct A146_extra_size) == 1, "");
_Static_assert(sizeof(A147) == 8, "");
_Static_assert(_Alignof(A147) == 1, "");
_Static_assert(sizeof(struct A147_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A147_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A147_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A147_extra_packed) == 1, "");
_Static_assert(sizeof(struct A147_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A147_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A147_extra_size) == 10, "");
_Static_assert(_Alignof(struct A147_extra_size) == 1, "");
_Static_assert(sizeof(A148) == 8, "");
_Static_assert(_Alignof(A148) == 1, "");
_Static_assert(sizeof(struct A148_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A148_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A148_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A148_extra_packed) == 1, "");
_Static_assert(sizeof(struct A148_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A148_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A148_extra_size) == 10, "");
_Static_assert(_Alignof(struct A148_extra_size) == 1, "");
_Static_assert(sizeof(A149) == 8, "");
_Static_assert(_Alignof(A149) == 1, "");
_Static_assert(sizeof(struct A149_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A149_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A149_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A149_extra_packed) == 1, "");
_Static_assert(sizeof(struct A149_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A149_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A149_extra_size) == 10, "");
_Static_assert(_Alignof(struct A149_extra_size) == 1, "");
_Static_assert(sizeof(A150) == 8, "");
_Static_assert(_Alignof(A150) == 1, "");
_Static_assert(sizeof(struct A150_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A150_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A150_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A150_extra_packed) == 1, "");
_Static_assert(sizeof(struct A150_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A150_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A150_extra_size) == 10, "");
_Static_assert(_Alignof(struct A150_extra_size) == 1, "");
_Static_assert(sizeof(A151) == 8, "");
_Static_assert(_Alignof(A151) == 1, "");
_Static_assert(sizeof(struct A151_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A151_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A151_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A151_extra_packed) == 1, "");
_Static_assert(sizeof(struct A151_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A151_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A151_extra_size) == 10, "");
_Static_assert(_Alignof(struct A151_extra_size) == 1, "");
_Static_assert(sizeof(A152) == 8, "");
_Static_assert(_Alignof(A152) == 1, "");
_Static_assert(sizeof(struct A152_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A152_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A152_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A152_extra_packed) == 1, "");
_Static_assert(sizeof(struct A152_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A152_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A152_extra_size) == 10, "");
_Static_assert(_Alignof(struct A152_extra_size) == 1, "");
_Static_assert(sizeof(A153) == 8, "");
_Static_assert(_Alignof(A153) == 1, "");
_Static_assert(sizeof(struct A153_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A153_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A153_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A153_extra_packed) == 1, "");
_Static_assert(sizeof(struct A153_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A153_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A153_extra_size) == 10, "");
_Static_assert(_Alignof(struct A153_extra_size) == 1, "");
_Static_assert(sizeof(A154) == 8, "");
_Static_assert(_Alignof(A154) == 1, "");
_Static_assert(sizeof(struct A154_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A154_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A154_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A154_extra_packed) == 1, "");
_Static_assert(sizeof(struct A154_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A154_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A154_extra_size) == 10, "");
_Static_assert(_Alignof(struct A154_extra_size) == 1, "");
_Static_assert(sizeof(A155) == 8, "");
_Static_assert(_Alignof(A155) == 1, "");
_Static_assert(sizeof(struct A155_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A155_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A155_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A155_extra_packed) == 1, "");
_Static_assert(sizeof(struct A155_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A155_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A155_extra_size) == 10, "");
_Static_assert(_Alignof(struct A155_extra_size) == 1, "");
_Static_assert(sizeof(A156) == 8, "");
_Static_assert(_Alignof(A156) == 1, "");
_Static_assert(sizeof(struct A156_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A156_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A156_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A156_extra_packed) == 1, "");
_Static_assert(sizeof(struct A156_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A156_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A156_extra_size) == 10, "");
_Static_assert(_Alignof(struct A156_extra_size) == 1, "");
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 1, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
_Static_assert(sizeof(B001) == 2, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 4, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 1, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
_Static_assert(sizeof(B003) == 2, "");
_Static_assert(_Alignof(B003) == 1, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 4, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
_Static_assert(sizeof(B004) == 2, "");
_Static_assert(_Alignof(B004) == 1, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 4, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 2, "");
_Static_assert(_Alignof(B005) == 1, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 4, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
_Static_assert(sizeof(B006) == 2, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 4, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 1, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
_Static_assert(sizeof(B008) == 2, "");
_Static_assert(_Alignof(B008) == 1, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 4, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
_Static_assert(sizeof(B009) == 2, "");
_Static_assert(_Alignof(B009) == 1, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 4, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 1, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
_Static_assert(sizeof(B011) == 2, "");
_Static_assert(_Alignof(B011) == 1, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 4, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 1, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
_Static_assert(sizeof(B013) == 2, "");
_Static_assert(_Alignof(B013) == 1, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 4, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
_Static_assert(sizeof(B014) == 2, "");
_Static_assert(_Alignof(B014) == 1, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 4, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
_Static_assert(sizeof(B015) == 2, "");
_Static_assert(_Alignof(B015) == 1, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 4, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
_Static_assert(sizeof(B016) == 2, "");
_Static_assert(_Alignof(B016) == 1, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 4, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
_Static_assert(sizeof(B021) == 4, "");
_Static_assert(_Alignof(B021) == 1, "");
_Static_assert(sizeof(struct B021_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B021_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B021_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B021_extra_packed) == 1, "");
_Static_assert(sizeof(struct B021_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B021_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B021_extra_size) == 6, "");
_Static_assert(_Alignof(struct B021_extra_size) == 1, "");
_Static_assert(sizeof(B022) == 4, "");
_Static_assert(_Alignof(B022) == 1, "");
_Static_assert(sizeof(struct B022_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B022_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B022_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B022_extra_packed) == 1, "");
_Static_assert(sizeof(struct B022_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B022_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B022_extra_size) == 6, "");
_Static_assert(_Alignof(struct B022_extra_size) == 1, "");
_Static_assert(sizeof(B023) == 4, "");
_Static_assert(_Alignof(B023) == 1, "");
_Static_assert(sizeof(struct B023_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B023_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B023_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B023_extra_packed) == 1, "");
_Static_assert(sizeof(struct B023_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B023_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B023_extra_size) == 6, "");
_Static_assert(_Alignof(struct B023_extra_size) == 1, "");
_Static_assert(sizeof(B024) == 4, "");
_Static_assert(_Alignof(B024) == 1, "");
_Static_assert(sizeof(struct B024_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B024_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B024_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B024_extra_packed) == 1, "");
_Static_assert(sizeof(struct B024_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B024_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B024_extra_size) == 6, "");
_Static_assert(_Alignof(struct B024_extra_size) == 1, "");
_Static_assert(sizeof(B025) == 4, "");
_Static_assert(_Alignof(B025) == 1, "");
_Static_assert(sizeof(struct B025_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B025_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B025_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B025_extra_packed) == 1, "");
_Static_assert(sizeof(struct B025_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B025_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B025_extra_size) == 6, "");
_Static_assert(_Alignof(struct B025_extra_size) == 1, "");
_Static_assert(sizeof(B026) == 4, "");
_Static_assert(_Alignof(B026) == 1, "");
_Static_assert(sizeof(struct B026_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B026_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B026_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B026_extra_packed) == 1, "");
_Static_assert(sizeof(struct B026_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B026_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B026_extra_size) == 6, "");
_Static_assert(_Alignof(struct B026_extra_size) == 1, "");
_Static_assert(sizeof(B027) == 4, "");
_Static_assert(_Alignof(B027) == 1, "");
_Static_assert(sizeof(struct B027_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B027_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B027_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B027_extra_packed) == 1, "");
_Static_assert(sizeof(struct B027_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B027_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B027_extra_size) == 6, "");
_Static_assert(_Alignof(struct B027_extra_size) == 1, "");
_Static_assert(sizeof(B028) == 4, "");
_Static_assert(_Alignof(B028) == 1, "");
_Static_assert(sizeof(struct B028_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B028_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B028_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B028_extra_packed) == 1, "");
_Static_assert(sizeof(struct B028_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B028_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B028_extra_size) == 6, "");
_Static_assert(_Alignof(struct B028_extra_size) == 1, "");
_Static_assert(sizeof(B029) == 4, "");
_Static_assert(_Alignof(B029) == 1, "");
_Static_assert(sizeof(struct B029_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B029_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B029_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B029_extra_packed) == 1, "");
_Static_assert(sizeof(struct B029_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B029_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B029_extra_size) == 6, "");
_Static_assert(_Alignof(struct B029_extra_size) == 1, "");
_Static_assert(sizeof(B030) == 4, "");
_Static_assert(_Alignof(B030) == 1, "");
_Static_assert(sizeof(struct B030_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B030_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B030_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B030_extra_packed) == 1, "");
_Static_assert(sizeof(struct B030_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B030_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B030_extra_size) == 6, "");
_Static_assert(_Alignof(struct B030_extra_size) == 1, "");
_Static_assert(sizeof(B031) == 4, "");
_Static_assert(_Alignof(B031) == 1, "");
_Static_assert(sizeof(struct B031_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B031_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B031_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B031_extra_packed) == 1, "");
_Static_assert(sizeof(struct B031_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B031_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B031_extra_size) == 6, "");
_Static_assert(_Alignof(struct B031_extra_size) == 1, "");
_Static_assert(sizeof(B032) == 4, "");
_Static_assert(_Alignof(B032) == 1, "");
_Static_assert(sizeof(struct B032_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B032_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B032_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B032_extra_packed) == 1, "");
_Static_assert(sizeof(struct B032_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B032_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B032_extra_size) == 6, "");
_Static_assert(_Alignof(struct B032_extra_size) == 1, "");
_Static_assert(sizeof(B033) == 4, "");
_Static_assert(_Alignof(B033) == 1, "");
_Static_assert(sizeof(struct B033_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B033_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B033_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B033_extra_packed) == 1, "");
_Static_assert(sizeof(struct B033_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B033_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B033_extra_size) == 6, "");
_Static_assert(_Alignof(struct B033_extra_size) == 1, "");
_Static_assert(sizeof(B034) == 4, "");
_Static_assert(_Alignof(B034) == 1, "");
_Static_assert(sizeof(struct B034_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B034_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B034_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B034_extra_packed) == 1, "");
_Static_assert(sizeof(struct B034_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B034_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B034_extra_size) == 6, "");
_Static_assert(_Alignof(struct B034_extra_size) == 1, "");
_Static_assert(sizeof(B035) == 4, "");
_Static_assert(_Alignof(B035) == 1, "");
_Static_assert(sizeof(struct B035_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B035_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B035_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B035_extra_packed) == 1, "");
_Static_assert(sizeof(struct B035_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B035_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B035_extra_size) == 6, "");
_Static_assert(_Alignof(struct B035_extra_size) == 1, "");
_Static_assert(sizeof(B036) == 4, "");
_Static_assert(_Alignof(B036) == 1, "");
_Static_assert(sizeof(struct B036_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B036_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B036_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B036_extra_packed) == 1, "");
_Static_assert(sizeof(struct B036_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B036_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B036_extra_size) == 6, "");
_Static_assert(_Alignof(struct B036_extra_size) == 1, "");
_Static_assert(sizeof(B041) == 8, "");
_Static_assert(_Alignof(B041) == 1, "");
_Static_assert(sizeof(struct B041_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B041_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B041_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B041_extra_packed) == 1, "");
_Static_assert(sizeof(struct B041_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B041_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B041_extra_size) == 10, "");
_Static_assert(_Alignof(struct B041_extra_size) == 1, "");
_Static_assert(sizeof(B042) == 8, "");
_Static_assert(_Alignof(B042) == 1, "");
_Static_assert(sizeof(struct B042_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B042_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B042_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B042_extra_packed) == 1, "");
_Static_assert(sizeof(struct B042_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B042_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B042_extra_size) == 10, "");
_Static_assert(_Alignof(struct B042_extra_size) == 1, "");
_Static_assert(sizeof(B043) == 8, "");
_Static_assert(_Alignof(B043) == 1, "");
_Static_assert(sizeof(struct B043_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B043_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B043_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B043_extra_packed) == 1, "");
_Static_assert(sizeof(struct B043_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B043_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B043_extra_size) == 10, "");
_Static_assert(_Alignof(struct B043_extra_size) == 1, "");
_Static_assert(sizeof(B044) == 8, "");
_Static_assert(_Alignof(B044) == 1, "");
_Static_assert(sizeof(struct B044_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B044_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B044_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B044_extra_packed) == 1, "");
_Static_assert(sizeof(struct B044_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B044_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B044_extra_size) == 10, "");
_Static_assert(_Alignof(struct B044_extra_size) == 1, "");
_Static_assert(sizeof(B045) == 8, "");
_Static_assert(_Alignof(B045) == 1, "");
_Static_assert(sizeof(struct B045_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B045_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B045_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B045_extra_packed) == 1, "");
_Static_assert(sizeof(struct B045_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B045_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B045_extra_size) == 10, "");
_Static_assert(_Alignof(struct B045_extra_size) == 1, "");
_Static_assert(sizeof(B046) == 8, "");
_Static_assert(_Alignof(B046) == 1, "");
_Static_assert(sizeof(struct B046_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B046_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B046_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B046_extra_packed) == 1, "");
_Static_assert(sizeof(struct B046_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B046_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B046_extra_size) == 10, "");
_Static_assert(_Alignof(struct B046_extra_size) == 1, "");
_Static_assert(sizeof(B047) == 8, "");
_Static_assert(_Alignof(B047) == 1, "");
_Static_assert(sizeof(struct B047_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B047_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B047_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B047_extra_packed) == 1, "");
_Static_assert(sizeof(struct B047_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B047_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B047_extra_size) == 10, "");
_Static_assert(_Alignof(struct B047_extra_size) == 1, "");
_Static_assert(sizeof(B048) == 8, "");
_Static_assert(_Alignof(B048) == 1, "");
_Static_assert(sizeof(struct B048_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B048_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B048_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B048_extra_packed) == 1, "");
_Static_assert(sizeof(struct B048_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B048_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B048_extra_size) == 10, "");
_Static_assert(_Alignof(struct B048_extra_size) == 1, "");
_Static_assert(sizeof(B049) == 8, "");
_Static_assert(_Alignof(B049) == 1, "");
_Static_assert(sizeof(struct B049_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B049_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B049_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B049_extra_packed) == 1, "");
_Static_assert(sizeof(struct B049_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B049_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B049_extra_size) == 10, "");
_Static_assert(_Alignof(struct B049_extra_size) == 1, "");
_Static_assert(sizeof(B050) == 8, "");
_Static_assert(_Alignof(B050) == 1, "");
_Static_assert(sizeof(struct B050_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B050_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B050_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B050_extra_packed) == 1, "");
_Static_assert(sizeof(struct B050_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B050_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B050_extra_size) == 10, "");
_Static_assert(_Alignof(struct B050_extra_size) == 1, "");
_Static_assert(sizeof(B051) == 8, "");
_Static_assert(_Alignof(B051) == 1, "");
_Static_assert(sizeof(struct B051_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B051_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B051_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B051_extra_packed) == 1, "");
_Static_assert(sizeof(struct B051_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B051_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B051_extra_size) == 10, "");
_Static_assert(_Alignof(struct B051_extra_size) == 1, "");
_Static_assert(sizeof(B052) == 8, "");
_Static_assert(_Alignof(B052) == 1, "");
_Static_assert(sizeof(struct B052_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B052_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B052_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B052_extra_packed) == 1, "");
_Static_assert(sizeof(struct B052_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B052_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B052_extra_size) == 10, "");
_Static_assert(_Alignof(struct B052_extra_size) == 1, "");
_Static_assert(sizeof(B053) == 8, "");
_Static_assert(_Alignof(B053) == 1, "");
_Static_assert(sizeof(struct B053_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B053_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B053_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B053_extra_packed) == 1, "");
_Static_assert(sizeof(struct B053_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B053_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B053_extra_size) == 10, "");
_Static_assert(_Alignof(struct B053_extra_size) == 1, "");
_Static_assert(sizeof(B054) == 8, "");
_Static_assert(_Alignof(B054) == 1, "");
_Static_assert(sizeof(struct B054_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B054_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B054_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B054_extra_packed) == 1, "");
_Static_assert(sizeof(struct B054_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B054_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B054_extra_size) == 10, "");
_Static_assert(_Alignof(struct B054_extra_size) == 1, "");
_Static_assert(sizeof(B055) == 8, "");
_Static_assert(_Alignof(B055) == 1, "");
_Static_assert(sizeof(struct B055_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B055_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B055_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B055_extra_packed) == 1, "");
_Static_assert(sizeof(struct B055_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B055_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B055_extra_size) == 10, "");
_Static_assert(_Alignof(struct B055_extra_size) == 1, "");
_Static_assert(sizeof(B056) == 8, "");
_Static_assert(_Alignof(B056) == 1, "");
_Static_assert(sizeof(struct B056_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B056_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B056_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B056_extra_packed) == 1, "");
_Static_assert(sizeof(struct B056_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B056_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B056_extra_size) == 10, "");
_Static_assert(_Alignof(struct B056_extra_size) == 1, "");
_Static_assert(sizeof(B061) == 8, "");
_Static_assert(_Alignof(B061) == 1, "");
_Static_assert(sizeof(struct B061_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B061_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B061_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B061_extra_packed) == 1, "");
_Static_assert(sizeof(struct B061_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B061_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B061_extra_size) == 10, "");
_Static_assert(_Alignof(struct B061_extra_size) == 1, "");
_Static_assert(sizeof(B062) == 8, "");
_Static_assert(_Alignof(B062) == 1, "");
_Static_assert(sizeof(struct B062_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B062_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B062_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B062_extra_packed) == 1, "");
_Static_assert(sizeof(struct B062_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B062_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B062_extra_size) == 10, "");
_Static_assert(_Alignof(struct B062_extra_size) == 1, "");
_Static_assert(sizeof(B063) == 8, "");
_Static_assert(_Alignof(B063) == 1, "");
_Static_assert(sizeof(struct B063_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B063_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B063_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B063_extra_packed) == 1, "");
_Static_assert(sizeof(struct B063_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B063_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B063_extra_size) == 10, "");
_Static_assert(_Alignof(struct B063_extra_size) == 1, "");
_Static_assert(sizeof(B064) == 8, "");
_Static_assert(_Alignof(B064) == 1, "");
_Static_assert(sizeof(struct B064_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B064_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B064_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B064_extra_packed) == 1, "");
_Static_assert(sizeof(struct B064_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B064_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B064_extra_size) == 10, "");
_Static_assert(_Alignof(struct B064_extra_size) == 1, "");
_Static_assert(sizeof(B065) == 8, "");
_Static_assert(_Alignof(B065) == 1, "");
_Static_assert(sizeof(struct B065_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B065_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B065_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B065_extra_packed) == 1, "");
_Static_assert(sizeof(struct B065_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B065_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B065_extra_size) == 10, "");
_Static_assert(_Alignof(struct B065_extra_size) == 1, "");
_Static_assert(sizeof(B066) == 8, "");
_Static_assert(_Alignof(B066) == 1, "");
_Static_assert(sizeof(struct B066_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B066_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B066_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B066_extra_packed) == 1, "");
_Static_assert(sizeof(struct B066_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B066_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B066_extra_size) == 10, "");
_Static_assert(_Alignof(struct B066_extra_size) == 1, "");
_Static_assert(sizeof(B067) == 8, "");
_Static_assert(_Alignof(B067) == 1, "");
_Static_assert(sizeof(struct B067_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B067_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B067_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B067_extra_packed) == 1, "");
_Static_assert(sizeof(struct B067_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B067_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B067_extra_size) == 10, "");
_Static_assert(_Alignof(struct B067_extra_size) == 1, "");
_Static_assert(sizeof(B068) == 8, "");
_Static_assert(_Alignof(B068) == 1, "");
_Static_assert(sizeof(struct B068_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B068_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B068_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B068_extra_packed) == 1, "");
_Static_assert(sizeof(struct B068_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B068_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B068_extra_size) == 10, "");
_Static_assert(_Alignof(struct B068_extra_size) == 1, "");
_Static_assert(sizeof(B069) == 8, "");
_Static_assert(_Alignof(B069) == 1, "");
_Static_assert(sizeof(struct B069_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B069_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B069_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B069_extra_packed) == 1, "");
_Static_assert(sizeof(struct B069_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B069_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B069_extra_size) == 10, "");
_Static_assert(_Alignof(struct B069_extra_size) == 1, "");
_Static_assert(sizeof(B070) == 8, "");
_Static_assert(_Alignof(B070) == 1, "");
_Static_assert(sizeof(struct B070_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B070_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B070_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B070_extra_packed) == 1, "");
_Static_assert(sizeof(struct B070_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B070_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B070_extra_size) == 10, "");
_Static_assert(_Alignof(struct B070_extra_size) == 1, "");
_Static_assert(sizeof(B071) == 8, "");
_Static_assert(_Alignof(B071) == 1, "");
_Static_assert(sizeof(struct B071_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B071_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B071_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B071_extra_packed) == 1, "");
_Static_assert(sizeof(struct B071_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B071_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B071_extra_size) == 10, "");
_Static_assert(_Alignof(struct B071_extra_size) == 1, "");
_Static_assert(sizeof(B072) == 8, "");
_Static_assert(_Alignof(B072) == 1, "");
_Static_assert(sizeof(struct B072_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B072_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B072_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B072_extra_packed) == 1, "");
_Static_assert(sizeof(struct B072_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B072_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B072_extra_size) == 10, "");
_Static_assert(_Alignof(struct B072_extra_size) == 1, "");
_Static_assert(sizeof(B073) == 8, "");
_Static_assert(_Alignof(B073) == 1, "");
_Static_assert(sizeof(struct B073_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B073_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B073_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B073_extra_packed) == 1, "");
_Static_assert(sizeof(struct B073_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B073_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B073_extra_size) == 10, "");
_Static_assert(_Alignof(struct B073_extra_size) == 1, "");
_Static_assert(sizeof(B074) == 8, "");
_Static_assert(_Alignof(B074) == 1, "");
_Static_assert(sizeof(struct B074_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B074_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B074_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B074_extra_packed) == 1, "");
_Static_assert(sizeof(struct B074_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B074_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B074_extra_size) == 10, "");
_Static_assert(_Alignof(struct B074_extra_size) == 1, "");
_Static_assert(sizeof(B075) == 8, "");
_Static_assert(_Alignof(B075) == 1, "");
_Static_assert(sizeof(struct B075_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B075_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B075_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B075_extra_packed) == 1, "");
_Static_assert(sizeof(struct B075_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B075_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B075_extra_size) == 10, "");
_Static_assert(_Alignof(struct B075_extra_size) == 1, "");
_Static_assert(sizeof(B076) == 8, "");
_Static_assert(_Alignof(B076) == 1, "");
_Static_assert(sizeof(struct B076_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B076_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B076_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B076_extra_packed) == 1, "");
_Static_assert(sizeof(struct B076_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B076_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B076_extra_size) == 10, "");
_Static_assert(_Alignof(struct B076_extra_size) == 1, "");
_Static_assert(sizeof(B081) == 2, "");
_Static_assert(_Alignof(B081) == 1, "");
_Static_assert(sizeof(struct B081_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B081_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B081_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B081_extra_packed) == 1, "");
_Static_assert(sizeof(struct B081_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B081_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B081_extra_size) == 4, "");
_Static_assert(_Alignof(struct B081_extra_size) == 1, "");
_Static_assert(sizeof(B082) == 2, "");
_Static_assert(_Alignof(B082) == 1, "");
_Static_assert(sizeof(struct B082_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B082_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B082_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B082_extra_packed) == 1, "");
_Static_assert(sizeof(struct B082_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B082_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B082_extra_size) == 4, "");
_Static_assert(_Alignof(struct B082_extra_size) == 1, "");
_Static_assert(sizeof(B083) == 2, "");
_Static_assert(_Alignof(B083) == 1, "");
_Static_assert(sizeof(struct B083_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B083_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B083_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B083_extra_packed) == 1, "");
_Static_assert(sizeof(struct B083_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B083_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B083_extra_size) == 4, "");
_Static_assert(_Alignof(struct B083_extra_size) == 1, "");
_Static_assert(sizeof(B084) == 2, "");
_Static_assert(_Alignof(B084) == 1, "");
_Static_assert(sizeof(struct B084_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B084_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B084_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B084_extra_packed) == 1, "");
_Static_assert(sizeof(struct B084_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B084_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B084_extra_size) == 4, "");
_Static_assert(_Alignof(struct B084_extra_size) == 1, "");
_Static_assert(sizeof(B085) == 2, "");
_Static_assert(_Alignof(B085) == 1, "");
_Static_assert(sizeof(struct B085_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B085_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B085_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B085_extra_packed) == 1, "");
_Static_assert(sizeof(struct B085_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B085_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B085_extra_size) == 4, "");
_Static_assert(_Alignof(struct B085_extra_size) == 1, "");
_Static_assert(sizeof(B086) == 2, "");
_Static_assert(_Alignof(B086) == 1, "");
_Static_assert(sizeof(struct B086_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B086_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B086_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B086_extra_packed) == 1, "");
_Static_assert(sizeof(struct B086_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B086_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B086_extra_size) == 4, "");
_Static_assert(_Alignof(struct B086_extra_size) == 1, "");
_Static_assert(sizeof(B087) == 2, "");
_Static_assert(_Alignof(B087) == 1, "");
_Static_assert(sizeof(struct B087_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B087_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B087_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B087_extra_packed) == 1, "");
_Static_assert(sizeof(struct B087_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B087_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B087_extra_size) == 4, "");
_Static_assert(_Alignof(struct B087_extra_size) == 1, "");
_Static_assert(sizeof(B088) == 2, "");
_Static_assert(_Alignof(B088) == 1, "");
_Static_assert(sizeof(struct B088_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B088_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B088_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B088_extra_packed) == 1, "");
_Static_assert(sizeof(struct B088_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B088_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B088_extra_size) == 4, "");
_Static_assert(_Alignof(struct B088_extra_size) == 1, "");
_Static_assert(sizeof(B089) == 2, "");
_Static_assert(_Alignof(B089) == 1, "");
_Static_assert(sizeof(struct B089_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B089_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B089_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B089_extra_packed) == 1, "");
_Static_assert(sizeof(struct B089_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B089_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B089_extra_size) == 4, "");
_Static_assert(_Alignof(struct B089_extra_size) == 1, "");
_Static_assert(sizeof(B090) == 2, "");
_Static_assert(_Alignof(B090) == 1, "");
_Static_assert(sizeof(struct B090_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B090_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B090_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B090_extra_packed) == 1, "");
_Static_assert(sizeof(struct B090_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B090_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B090_extra_size) == 4, "");
_Static_assert(_Alignof(struct B090_extra_size) == 1, "");
_Static_assert(sizeof(B091) == 2, "");
_Static_assert(_Alignof(B091) == 1, "");
_Static_assert(sizeof(struct B091_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B091_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B091_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B091_extra_packed) == 1, "");
_Static_assert(sizeof(struct B091_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B091_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B091_extra_size) == 4, "");
_Static_assert(_Alignof(struct B091_extra_size) == 1, "");
_Static_assert(sizeof(B092) == 2, "");
_Static_assert(_Alignof(B092) == 1, "");
_Static_assert(sizeof(struct B092_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B092_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B092_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B092_extra_packed) == 1, "");
_Static_assert(sizeof(struct B092_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B092_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B092_extra_size) == 4, "");
_Static_assert(_Alignof(struct B092_extra_size) == 1, "");
_Static_assert(sizeof(B093) == 2, "");
_Static_assert(_Alignof(B093) == 1, "");
_Static_assert(sizeof(struct B093_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B093_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B093_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B093_extra_packed) == 1, "");
_Static_assert(sizeof(struct B093_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B093_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B093_extra_size) == 4, "");
_Static_assert(_Alignof(struct B093_extra_size) == 1, "");
_Static_assert(sizeof(B094) == 2, "");
_Static_assert(_Alignof(B094) == 1, "");
_Static_assert(sizeof(struct B094_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B094_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B094_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B094_extra_packed) == 1, "");
_Static_assert(sizeof(struct B094_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B094_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B094_extra_size) == 4, "");
_Static_assert(_Alignof(struct B094_extra_size) == 1, "");
_Static_assert(sizeof(B095) == 2, "");
_Static_assert(_Alignof(B095) == 1, "");
_Static_assert(sizeof(struct B095_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B095_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B095_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B095_extra_packed) == 1, "");
_Static_assert(sizeof(struct B095_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B095_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B095_extra_size) == 4, "");
_Static_assert(_Alignof(struct B095_extra_size) == 1, "");
_Static_assert(sizeof(B096) == 2, "");
_Static_assert(_Alignof(B096) == 1, "");
_Static_assert(sizeof(struct B096_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B096_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B096_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B096_extra_packed) == 1, "");
_Static_assert(sizeof(struct B096_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B096_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B096_extra_size) == 4, "");
_Static_assert(_Alignof(struct B096_extra_size) == 1, "");
_Static_assert(sizeof(B101) == 4, "");
_Static_assert(_Alignof(B101) == 1, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 6, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
_Static_assert(sizeof(B102) == 4, "");
_Static_assert(_Alignof(B102) == 1, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 6, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 1, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 1, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 4, "");
_Static_assert(_Alignof(B105) == 1, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 6, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
_Static_assert(sizeof(B106) == 4, "");
_Static_assert(_Alignof(B106) == 1, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 6, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
_Static_assert(sizeof(B107) == 4, "");
_Static_assert(_Alignof(B107) == 1, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 6, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 1, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
_Static_assert(sizeof(B109) == 4, "");
_Static_assert(_Alignof(B109) == 1, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 6, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 1, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 1, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 1, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 1, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 1, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 1, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 1, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
_Static_assert(sizeof(B121) == 8, "");
_Static_assert(_Alignof(B121) == 1, "");
_Static_assert(sizeof(struct B121_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B121_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B121_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B121_extra_packed) == 1, "");
_Static_assert(sizeof(struct B121_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B121_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B121_extra_size) == 10, "");
_Static_assert(_Alignof(struct B121_extra_size) == 1, "");
_Static_assert(sizeof(B122) == 8, "");
_Static_assert(_Alignof(B122) == 1, "");
_Static_assert(sizeof(struct B122_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B122_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B122_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B122_extra_packed) == 1, "");
_Static_assert(sizeof(struct B122_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B122_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B122_extra_size) == 10, "");
_Static_assert(_Alignof(struct B122_extra_size) == 1, "");
_Static_assert(sizeof(B123) == 8, "");
_Static_assert(_Alignof(B123) == 1, "");
_Static_assert(sizeof(struct B123_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B123_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B123_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B123_extra_packed) == 1, "");
_Static_assert(sizeof(struct B123_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B123_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B123_extra_size) == 10, "");
_Static_assert(_Alignof(struct B123_extra_size) == 1, "");
_Static_assert(sizeof(B124) == 8, "");
_Static_assert(_Alignof(B124) == 1, "");
_Static_assert(sizeof(struct B124_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B124_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B124_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B124_extra_packed) == 1, "");
_Static_assert(sizeof(struct B124_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B124_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B124_extra_size) == 10, "");
_Static_assert(_Alignof(struct B124_extra_size) == 1, "");
_Static_assert(sizeof(B125) == 8, "");
_Static_assert(_Alignof(B125) == 1, "");
_Static_assert(sizeof(struct B125_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B125_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B125_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B125_extra_packed) == 1, "");
_Static_assert(sizeof(struct B125_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B125_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B125_extra_size) == 10, "");
_Static_assert(_Alignof(struct B125_extra_size) == 1, "");
_Static_assert(sizeof(B126) == 8, "");
_Static_assert(_Alignof(B126) == 1, "");
_Static_assert(sizeof(struct B126_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B126_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B126_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B126_extra_packed) == 1, "");
_Static_assert(sizeof(struct B126_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B126_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B126_extra_size) == 10, "");
_Static_assert(_Alignof(struct B126_extra_size) == 1, "");
_Static_assert(sizeof(B127) == 8, "");
_Static_assert(_Alignof(B127) == 1, "");
_Static_assert(sizeof(struct B127_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B127_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B127_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B127_extra_packed) == 1, "");
_Static_assert(sizeof(struct B127_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B127_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B127_extra_size) == 10, "");
_Static_assert(_Alignof(struct B127_extra_size) == 1, "");
_Static_assert(sizeof(B128) == 8, "");
_Static_assert(_Alignof(B128) == 1, "");
_Static_assert(sizeof(struct B128_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B128_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B128_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B128_extra_packed) == 1, "");
_Static_assert(sizeof(struct B128_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B128_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B128_extra_size) == 10, "");
_Static_assert(_Alignof(struct B128_extra_size) == 1, "");
_Static_assert(sizeof(B129) == 8, "");
_Static_assert(_Alignof(B129) == 1, "");
_Static_assert(sizeof(struct B129_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B129_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B129_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B129_extra_packed) == 1, "");
_Static_assert(sizeof(struct B129_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B129_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B129_extra_size) == 10, "");
_Static_assert(_Alignof(struct B129_extra_size) == 1, "");
_Static_assert(sizeof(B130) == 8, "");
_Static_assert(_Alignof(B130) == 1, "");
_Static_assert(sizeof(struct B130_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B130_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B130_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B130_extra_packed) == 1, "");
_Static_assert(sizeof(struct B130_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B130_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B130_extra_size) == 10, "");
_Static_assert(_Alignof(struct B130_extra_size) == 1, "");
_Static_assert(sizeof(B131) == 8, "");
_Static_assert(_Alignof(B131) == 1, "");
_Static_assert(sizeof(struct B131_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B131_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B131_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B131_extra_packed) == 1, "");
_Static_assert(sizeof(struct B131_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B131_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B131_extra_size) == 10, "");
_Static_assert(_Alignof(struct B131_extra_size) == 1, "");
_Static_assert(sizeof(B132) == 8, "");
_Static_assert(_Alignof(B132) == 1, "");
_Static_assert(sizeof(struct B132_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B132_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B132_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B132_extra_packed) == 1, "");
_Static_assert(sizeof(struct B132_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B132_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B132_extra_size) == 10, "");
_Static_assert(_Alignof(struct B132_extra_size) == 1, "");
_Static_assert(sizeof(B133) == 8, "");
_Static_assert(_Alignof(B133) == 1, "");
_Static_assert(sizeof(struct B133_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B133_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B133_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B133_extra_packed) == 1, "");
_Static_assert(sizeof(struct B133_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B133_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B133_extra_size) == 10, "");
_Static_assert(_Alignof(struct B133_extra_size) == 1, "");
_Static_assert(sizeof(B134) == 8, "");
_Static_assert(_Alignof(B134) == 1, "");
_Static_assert(sizeof(struct B134_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B134_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B134_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B134_extra_packed) == 1, "");
_Static_assert(sizeof(struct B134_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B134_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B134_extra_size) == 10, "");
_Static_assert(_Alignof(struct B134_extra_size) == 1, "");
_Static_assert(sizeof(B135) == 8, "");
_Static_assert(_Alignof(B135) == 1, "");
_Static_assert(sizeof(struct B135_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B135_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B135_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B135_extra_packed) == 1, "");
_Static_assert(sizeof(struct B135_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B135_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B135_extra_size) == 10, "");
_Static_assert(_Alignof(struct B135_extra_size) == 1, "");
_Static_assert(sizeof(B136) == 8, "");
_Static_assert(_Alignof(B136) == 1, "");
_Static_assert(sizeof(struct B136_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B136_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B136_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B136_extra_packed) == 1, "");
_Static_assert(sizeof(struct B136_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B136_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B136_extra_size) == 10, "");
_Static_assert(_Alignof(struct B136_extra_size) == 1, "");
_Static_assert(sizeof(B141) == 8, "");
_Static_assert(_Alignof(B141) == 1, "");
_Static_assert(sizeof(struct B141_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B141_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B141_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B141_extra_packed) == 1, "");
_Static_assert(sizeof(struct B141_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B141_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B141_extra_size) == 10, "");
_Static_assert(_Alignof(struct B141_extra_size) == 1, "");
_Static_assert(sizeof(B142) == 8, "");
_Static_assert(_Alignof(B142) == 1, "");
_Static_assert(sizeof(struct B142_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B142_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B142_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B142_extra_packed) == 1, "");
_Static_assert(sizeof(struct B142_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B142_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B142_extra_size) == 10, "");
_Static_assert(_Alignof(struct B142_extra_size) == 1, "");
_Static_assert(sizeof(B143) == 8, "");
_Static_assert(_Alignof(B143) == 1, "");
_Static_assert(sizeof(struct B143_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B143_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B143_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B143_extra_packed) == 1, "");
_Static_assert(sizeof(struct B143_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B143_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B143_extra_size) == 10, "");
_Static_assert(_Alignof(struct B143_extra_size) == 1, "");
_Static_assert(sizeof(B144) == 8, "");
_Static_assert(_Alignof(B144) == 1, "");
_Static_assert(sizeof(struct B144_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B144_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B144_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B144_extra_packed) == 1, "");
_Static_assert(sizeof(struct B144_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B144_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B144_extra_size) == 10, "");
_Static_assert(_Alignof(struct B144_extra_size) == 1, "");
_Static_assert(sizeof(B145) == 8, "");
_Static_assert(_Alignof(B145) == 1, "");
_Static_assert(sizeof(struct B145_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B145_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B145_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B145_extra_packed) == 1, "");
_Static_assert(sizeof(struct B145_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B145_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B145_extra_size) == 10, "");
_Static_assert(_Alignof(struct B145_extra_size) == 1, "");
_Static_assert(sizeof(B146) == 8, "");
_Static_assert(_Alignof(B146) == 1, "");
_Static_assert(sizeof(struct B146_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B146_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B146_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B146_extra_packed) == 1, "");
_Static_assert(sizeof(struct B146_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B146_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B146_extra_size) == 10, "");
_Static_assert(_Alignof(struct B146_extra_size) == 1, "");
_Static_assert(sizeof(B147) == 8, "");
_Static_assert(_Alignof(B147) == 1, "");
_Static_assert(sizeof(struct B147_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B147_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B147_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B147_extra_packed) == 1, "");
_Static_assert(sizeof(struct B147_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B147_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B147_extra_size) == 10, "");
_Static_assert(_Alignof(struct B147_extra_size) == 1, "");
_Static_assert(sizeof(B148) == 8, "");
_Static_assert(_Alignof(B148) == 1, "");
_Static_assert(sizeof(struct B148_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B148_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B148_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B148_extra_packed) == 1, "");
_Static_assert(sizeof(struct B148_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B148_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B148_extra_size) == 10, "");
_Static_assert(_Alignof(struct B148_extra_size) == 1, "");
_Static_assert(sizeof(B149) == 8, "");
_Static_assert(_Alignof(B149) == 1, "");
_Static_assert(sizeof(struct B149_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B149_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B149_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B149_extra_packed) == 1, "");
_Static_assert(sizeof(struct B149_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B149_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B149_extra_size) == 10, "");
_Static_assert(_Alignof(struct B149_extra_size) == 1, "");
_Static_assert(sizeof(B150) == 8, "");
_Static_assert(_Alignof(B150) == 1, "");
_Static_assert(sizeof(struct B150_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B150_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B150_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B150_extra_packed) == 1, "");
_Static_assert(sizeof(struct B150_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B150_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B150_extra_size) == 10, "");
_Static_assert(_Alignof(struct B150_extra_size) == 1, "");
_Static_assert(sizeof(B151) == 8, "");
_Static_assert(_Alignof(B151) == 1, "");
_Static_assert(sizeof(struct B151_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B151_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B151_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B151_extra_packed) == 1, "");
_Static_assert(sizeof(struct B151_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B151_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B151_extra_size) == 10, "");
_Static_assert(_Alignof(struct B151_extra_size) == 1, "");
_Static_assert(sizeof(B152) == 8, "");
_Static_assert(_Alignof(B152) == 1, "");
_Static_assert(sizeof(struct B152_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B152_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B152_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B152_extra_packed) == 1, "");
_Static_assert(sizeof(struct B152_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B152_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B152_extra_size) == 10, "");
_Static_assert(_Alignof(struct B152_extra_size) == 1, "");
_Static_assert(sizeof(B153) == 8, "");
_Static_assert(_Alignof(B153) == 1, "");
_Static_assert(sizeof(struct B153_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B153_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B153_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B153_extra_packed) == 1, "");
_Static_assert(sizeof(struct B153_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B153_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B153_extra_size) == 10, "");
_Static_assert(_Alignof(struct B153_extra_size) == 1, "");
_Static_assert(sizeof(B154) == 8, "");
_Static_assert(_Alignof(B154) == 1, "");
_Static_assert(sizeof(struct B154_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B154_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B154_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B154_extra_packed) == 1, "");
_Static_assert(sizeof(struct B154_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B154_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B154_extra_size) == 10, "");
_Static_assert(_Alignof(struct B154_extra_size) == 1, "");
_Static_assert(sizeof(B155) == 8, "");
_Static_assert(_Alignof(B155) == 1, "");
_Static_assert(sizeof(struct B155_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B155_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B155_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B155_extra_packed) == 1, "");
_Static_assert(sizeof(struct B155_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B155_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B155_extra_size) == 10, "");
_Static_assert(_Alignof(struct B155_extra_size) == 1, "");
_Static_assert(sizeof(B156) == 8, "");
_Static_assert(_Alignof(B156) == 1, "");
_Static_assert(sizeof(struct B156_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B156_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B156_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B156_extra_packed) == 1, "");
_Static_assert(sizeof(struct B156_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B156_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B156_extra_size) == 10, "");
_Static_assert(_Alignof(struct B156_extra_size) == 1, "");
// MAPPING|FOUR|hexagon-generic-linux-musl:Clang|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl")
#elif defined(FOUR)
_Static_assert(sizeof(A000) == 1, "");
_Static_assert(_Alignof(A000) == 1, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 3, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
_Static_assert(sizeof(A001) == 1, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 3, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
_Static_assert(sizeof(A002) == 1, "");
_Static_assert(_Alignof(A002) == 1, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 3, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
_Static_assert(sizeof(A003) == 1, "");
_Static_assert(_Alignof(A003) == 1, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 3, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
_Static_assert(sizeof(A004) == 1, "");
_Static_assert(_Alignof(A004) == 1, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 3, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 1, "");
_Static_assert(_Alignof(A005) == 1, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 3, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
_Static_assert(sizeof(A006) == 1, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 3, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
_Static_assert(sizeof(A007) == 1, "");
_Static_assert(_Alignof(A007) == 1, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 3, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
_Static_assert(sizeof(A008) == 1, "");
_Static_assert(_Alignof(A008) == 1, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 3, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
_Static_assert(sizeof(A009) == 2, "");
_Static_assert(_Alignof(A009) == 2, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A009_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 4, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
_Static_assert(sizeof(A010) == 2, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 4, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
_Static_assert(sizeof(A011) == 2, "");
_Static_assert(_Alignof(A011) == 2, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 4, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
_Static_assert(sizeof(A012) == 2, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 4, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
_Static_assert(sizeof(A013) == 2, "");
_Static_assert(_Alignof(A013) == 2, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A013_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 4, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
_Static_assert(sizeof(A014) == 2, "");
_Static_assert(_Alignof(A014) == 2, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A014_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 4, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
_Static_assert(sizeof(A015) == 2, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 4, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
_Static_assert(sizeof(A016) == 2, "");
_Static_assert(_Alignof(A016) == 2, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 4, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
_Static_assert(sizeof(A021) == 4, "");
_Static_assert(_Alignof(A021) == 4, "");
_Static_assert(sizeof(struct A021_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A021_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A021_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A021_extra_packed) == 1, "");
_Static_assert(sizeof(struct A021_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A021_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A021_extra_size) == 6, "");
_Static_assert(_Alignof(struct A021_extra_size) == 1, "");
_Static_assert(sizeof(A022) == 4, "");
_Static_assert(_Alignof(A022) == 4, "");
_Static_assert(sizeof(struct A022_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A022_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A022_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A022_extra_packed) == 1, "");
_Static_assert(sizeof(struct A022_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A022_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A022_extra_size) == 6, "");
_Static_assert(_Alignof(struct A022_extra_size) == 1, "");
_Static_assert(sizeof(A023) == 4, "");
_Static_assert(_Alignof(A023) == 4, "");
_Static_assert(sizeof(struct A023_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A023_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A023_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A023_extra_packed) == 1, "");
_Static_assert(sizeof(struct A023_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A023_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A023_extra_size) == 6, "");
_Static_assert(_Alignof(struct A023_extra_size) == 1, "");
_Static_assert(sizeof(A024) == 4, "");
_Static_assert(_Alignof(A024) == 4, "");
_Static_assert(sizeof(struct A024_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A024_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A024_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A024_extra_packed) == 1, "");
_Static_assert(sizeof(struct A024_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A024_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A024_extra_size) == 6, "");
_Static_assert(_Alignof(struct A024_extra_size) == 1, "");
_Static_assert(sizeof(A025) == 4, "");
_Static_assert(_Alignof(A025) == 4, "");
_Static_assert(sizeof(struct A025_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A025_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A025_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A025_extra_packed) == 1, "");
_Static_assert(sizeof(struct A025_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A025_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A025_extra_size) == 6, "");
_Static_assert(_Alignof(struct A025_extra_size) == 1, "");
_Static_assert(sizeof(A026) == 4, "");
_Static_assert(_Alignof(A026) == 4, "");
_Static_assert(sizeof(struct A026_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A026_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A026_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A026_extra_packed) == 1, "");
_Static_assert(sizeof(struct A026_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A026_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A026_extra_size) == 6, "");
_Static_assert(_Alignof(struct A026_extra_size) == 1, "");
_Static_assert(sizeof(A027) == 4, "");
_Static_assert(_Alignof(A027) == 4, "");
_Static_assert(sizeof(struct A027_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A027_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A027_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A027_extra_packed) == 1, "");
_Static_assert(sizeof(struct A027_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A027_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A027_extra_size) == 6, "");
_Static_assert(_Alignof(struct A027_extra_size) == 1, "");
_Static_assert(sizeof(A028) == 4, "");
_Static_assert(_Alignof(A028) == 4, "");
_Static_assert(sizeof(struct A028_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A028_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A028_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A028_extra_packed) == 1, "");
_Static_assert(sizeof(struct A028_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A028_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A028_extra_size) == 6, "");
_Static_assert(_Alignof(struct A028_extra_size) == 1, "");
_Static_assert(sizeof(A029) == 4, "");
_Static_assert(_Alignof(A029) == 4, "");
_Static_assert(sizeof(struct A029_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A029_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A029_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A029_extra_packed) == 1, "");
_Static_assert(sizeof(struct A029_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A029_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A029_extra_size) == 6, "");
_Static_assert(_Alignof(struct A029_extra_size) == 1, "");
_Static_assert(sizeof(A030) == 4, "");
_Static_assert(_Alignof(A030) == 4, "");
_Static_assert(sizeof(struct A030_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A030_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A030_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A030_extra_packed) == 1, "");
_Static_assert(sizeof(struct A030_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A030_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A030_extra_size) == 6, "");
_Static_assert(_Alignof(struct A030_extra_size) == 1, "");
_Static_assert(sizeof(A031) == 4, "");
_Static_assert(_Alignof(A031) == 4, "");
_Static_assert(sizeof(struct A031_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A031_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A031_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A031_extra_packed) == 1, "");
_Static_assert(sizeof(struct A031_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A031_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A031_extra_size) == 6, "");
_Static_assert(_Alignof(struct A031_extra_size) == 1, "");
_Static_assert(sizeof(A032) == 4, "");
_Static_assert(_Alignof(A032) == 4, "");
_Static_assert(sizeof(struct A032_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A032_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A032_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A032_extra_packed) == 1, "");
_Static_assert(sizeof(struct A032_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A032_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A032_extra_size) == 6, "");
_Static_assert(_Alignof(struct A032_extra_size) == 1, "");
_Static_assert(sizeof(A033) == 4, "");
_Static_assert(_Alignof(A033) == 4, "");
_Static_assert(sizeof(struct A033_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A033_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A033_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A033_extra_packed) == 1, "");
_Static_assert(sizeof(struct A033_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A033_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A033_extra_size) == 6, "");
_Static_assert(_Alignof(struct A033_extra_size) == 1, "");
_Static_assert(sizeof(A034) == 4, "");
_Static_assert(_Alignof(A034) == 4, "");
_Static_assert(sizeof(struct A034_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A034_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A034_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A034_extra_packed) == 1, "");
_Static_assert(sizeof(struct A034_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A034_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A034_extra_size) == 6, "");
_Static_assert(_Alignof(struct A034_extra_size) == 1, "");
_Static_assert(sizeof(A035) == 4, "");
_Static_assert(_Alignof(A035) == 4, "");
_Static_assert(sizeof(struct A035_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A035_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A035_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A035_extra_packed) == 1, "");
_Static_assert(sizeof(struct A035_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A035_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A035_extra_size) == 6, "");
_Static_assert(_Alignof(struct A035_extra_size) == 1, "");
_Static_assert(sizeof(A036) == 4, "");
_Static_assert(_Alignof(A036) == 4, "");
_Static_assert(sizeof(struct A036_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A036_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A036_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A036_extra_packed) == 1, "");
_Static_assert(sizeof(struct A036_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A036_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A036_extra_size) == 6, "");
_Static_assert(_Alignof(struct A036_extra_size) == 1, "");
_Static_assert(sizeof(A041) == 8, "");
_Static_assert(_Alignof(A041) == 8, "");
_Static_assert(sizeof(struct A041_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A041_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A041_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A041_extra_packed) == 1, "");
_Static_assert(sizeof(struct A041_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A041_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A041_extra_size) == 10, "");
_Static_assert(_Alignof(struct A041_extra_size) == 1, "");
_Static_assert(sizeof(A042) == 8, "");
_Static_assert(_Alignof(A042) == 8, "");
_Static_assert(sizeof(struct A042_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A042_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A042_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A042_extra_packed) == 1, "");
_Static_assert(sizeof(struct A042_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A042_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A042_extra_size) == 10, "");
_Static_assert(_Alignof(struct A042_extra_size) == 1, "");
_Static_assert(sizeof(A043) == 8, "");
_Static_assert(_Alignof(A043) == 8, "");
_Static_assert(sizeof(struct A043_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A043_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A043_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A043_extra_packed) == 1, "");
_Static_assert(sizeof(struct A043_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A043_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A043_extra_size) == 10, "");
_Static_assert(_Alignof(struct A043_extra_size) == 1, "");
_Static_assert(sizeof(A044) == 8, "");
_Static_assert(_Alignof(A044) == 8, "");
_Static_assert(sizeof(struct A044_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A044_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A044_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A044_extra_packed) == 1, "");
_Static_assert(sizeof(struct A044_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A044_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A044_extra_size) == 10, "");
_Static_assert(_Alignof(struct A044_extra_size) == 1, "");
_Static_assert(sizeof(A045) == 8, "");
_Static_assert(_Alignof(A045) == 8, "");
_Static_assert(sizeof(struct A045_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A045_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A045_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A045_extra_packed) == 1, "");
_Static_assert(sizeof(struct A045_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A045_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A045_extra_size) == 10, "");
_Static_assert(_Alignof(struct A045_extra_size) == 1, "");
_Static_assert(sizeof(A046) == 8, "");
_Static_assert(_Alignof(A046) == 8, "");
_Static_assert(sizeof(struct A046_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A046_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A046_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A046_extra_packed) == 1, "");
_Static_assert(sizeof(struct A046_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A046_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A046_extra_size) == 10, "");
_Static_assert(_Alignof(struct A046_extra_size) == 1, "");
_Static_assert(sizeof(A047) == 8, "");
_Static_assert(_Alignof(A047) == 8, "");
_Static_assert(sizeof(struct A047_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A047_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A047_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A047_extra_packed) == 1, "");
_Static_assert(sizeof(struct A047_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A047_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A047_extra_size) == 10, "");
_Static_assert(_Alignof(struct A047_extra_size) == 1, "");
_Static_assert(sizeof(A048) == 8, "");
_Static_assert(_Alignof(A048) == 8, "");
_Static_assert(sizeof(struct A048_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A048_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A048_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A048_extra_packed) == 1, "");
_Static_assert(sizeof(struct A048_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A048_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A048_extra_size) == 10, "");
_Static_assert(_Alignof(struct A048_extra_size) == 1, "");
_Static_assert(sizeof(A049) == 8, "");
_Static_assert(_Alignof(A049) == 8, "");
_Static_assert(sizeof(struct A049_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A049_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A049_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A049_extra_packed) == 1, "");
_Static_assert(sizeof(struct A049_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A049_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A049_extra_size) == 10, "");
_Static_assert(_Alignof(struct A049_extra_size) == 1, "");
_Static_assert(sizeof(A050) == 8, "");
_Static_assert(_Alignof(A050) == 8, "");
_Static_assert(sizeof(struct A050_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A050_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A050_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A050_extra_packed) == 1, "");
_Static_assert(sizeof(struct A050_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A050_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A050_extra_size) == 10, "");
_Static_assert(_Alignof(struct A050_extra_size) == 1, "");
_Static_assert(sizeof(A051) == 8, "");
_Static_assert(_Alignof(A051) == 8, "");
_Static_assert(sizeof(struct A051_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A051_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A051_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A051_extra_packed) == 1, "");
_Static_assert(sizeof(struct A051_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A051_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A051_extra_size) == 10, "");
_Static_assert(_Alignof(struct A051_extra_size) == 1, "");
_Static_assert(sizeof(A052) == 8, "");
_Static_assert(_Alignof(A052) == 8, "");
_Static_assert(sizeof(struct A052_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A052_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A052_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A052_extra_packed) == 1, "");
_Static_assert(sizeof(struct A052_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A052_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A052_extra_size) == 10, "");
_Static_assert(_Alignof(struct A052_extra_size) == 1, "");
_Static_assert(sizeof(A053) == 8, "");
_Static_assert(_Alignof(A053) == 8, "");
_Static_assert(sizeof(struct A053_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A053_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A053_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A053_extra_packed) == 1, "");
_Static_assert(sizeof(struct A053_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A053_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A053_extra_size) == 10, "");
_Static_assert(_Alignof(struct A053_extra_size) == 1, "");
_Static_assert(sizeof(A054) == 8, "");
_Static_assert(_Alignof(A054) == 8, "");
_Static_assert(sizeof(struct A054_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A054_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A054_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A054_extra_packed) == 1, "");
_Static_assert(sizeof(struct A054_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A054_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A054_extra_size) == 10, "");
_Static_assert(_Alignof(struct A054_extra_size) == 1, "");
_Static_assert(sizeof(A055) == 8, "");
_Static_assert(_Alignof(A055) == 8, "");
_Static_assert(sizeof(struct A055_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A055_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A055_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A055_extra_packed) == 1, "");
_Static_assert(sizeof(struct A055_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A055_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A055_extra_size) == 10, "");
_Static_assert(_Alignof(struct A055_extra_size) == 1, "");
_Static_assert(sizeof(A056) == 8, "");
_Static_assert(_Alignof(A056) == 8, "");
_Static_assert(sizeof(struct A056_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A056_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A056_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A056_extra_packed) == 1, "");
_Static_assert(sizeof(struct A056_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A056_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A056_extra_size) == 10, "");
_Static_assert(_Alignof(struct A056_extra_size) == 1, "");
_Static_assert(sizeof(A061) == 8, "");
_Static_assert(_Alignof(A061) == 8, "");
_Static_assert(sizeof(struct A061_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A061_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A061_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A061_extra_packed) == 1, "");
_Static_assert(sizeof(struct A061_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A061_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A061_extra_size) == 10, "");
_Static_assert(_Alignof(struct A061_extra_size) == 1, "");
_Static_assert(sizeof(A062) == 8, "");
_Static_assert(_Alignof(A062) == 8, "");
_Static_assert(sizeof(struct A062_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A062_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A062_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A062_extra_packed) == 1, "");
_Static_assert(sizeof(struct A062_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A062_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A062_extra_size) == 10, "");
_Static_assert(_Alignof(struct A062_extra_size) == 1, "");
_Static_assert(sizeof(A063) == 8, "");
_Static_assert(_Alignof(A063) == 8, "");
_Static_assert(sizeof(struct A063_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A063_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A063_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A063_extra_packed) == 1, "");
_Static_assert(sizeof(struct A063_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A063_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A063_extra_size) == 10, "");
_Static_assert(_Alignof(struct A063_extra_size) == 1, "");
_Static_assert(sizeof(A064) == 8, "");
_Static_assert(_Alignof(A064) == 8, "");
_Static_assert(sizeof(struct A064_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A064_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A064_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A064_extra_packed) == 1, "");
_Static_assert(sizeof(struct A064_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A064_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A064_extra_size) == 10, "");
_Static_assert(_Alignof(struct A064_extra_size) == 1, "");
_Static_assert(sizeof(A065) == 8, "");
_Static_assert(_Alignof(A065) == 8, "");
_Static_assert(sizeof(struct A065_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A065_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A065_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A065_extra_packed) == 1, "");
_Static_assert(sizeof(struct A065_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A065_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A065_extra_size) == 10, "");
_Static_assert(_Alignof(struct A065_extra_size) == 1, "");
_Static_assert(sizeof(A066) == 8, "");
_Static_assert(_Alignof(A066) == 8, "");
_Static_assert(sizeof(struct A066_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A066_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A066_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A066_extra_packed) == 1, "");
_Static_assert(sizeof(struct A066_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A066_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A066_extra_size) == 10, "");
_Static_assert(_Alignof(struct A066_extra_size) == 1, "");
_Static_assert(sizeof(A067) == 8, "");
_Static_assert(_Alignof(A067) == 8, "");
_Static_assert(sizeof(struct A067_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A067_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A067_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A067_extra_packed) == 1, "");
_Static_assert(sizeof(struct A067_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A067_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A067_extra_size) == 10, "");
_Static_assert(_Alignof(struct A067_extra_size) == 1, "");
_Static_assert(sizeof(A068) == 8, "");
_Static_assert(_Alignof(A068) == 8, "");
_Static_assert(sizeof(struct A068_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A068_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A068_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A068_extra_packed) == 1, "");
_Static_assert(sizeof(struct A068_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A068_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A068_extra_size) == 10, "");
_Static_assert(_Alignof(struct A068_extra_size) == 1, "");
_Static_assert(sizeof(A069) == 8, "");
_Static_assert(_Alignof(A069) == 8, "");
_Static_assert(sizeof(struct A069_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A069_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A069_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A069_extra_packed) == 1, "");
_Static_assert(sizeof(struct A069_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A069_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A069_extra_size) == 10, "");
_Static_assert(_Alignof(struct A069_extra_size) == 1, "");
_Static_assert(sizeof(A070) == 8, "");
_Static_assert(_Alignof(A070) == 8, "");
_Static_assert(sizeof(struct A070_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A070_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A070_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A070_extra_packed) == 1, "");
_Static_assert(sizeof(struct A070_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A070_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A070_extra_size) == 10, "");
_Static_assert(_Alignof(struct A070_extra_size) == 1, "");
_Static_assert(sizeof(A071) == 8, "");
_Static_assert(_Alignof(A071) == 8, "");
_Static_assert(sizeof(struct A071_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A071_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A071_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A071_extra_packed) == 1, "");
_Static_assert(sizeof(struct A071_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A071_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A071_extra_size) == 10, "");
_Static_assert(_Alignof(struct A071_extra_size) == 1, "");
_Static_assert(sizeof(A072) == 8, "");
_Static_assert(_Alignof(A072) == 8, "");
_Static_assert(sizeof(struct A072_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A072_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A072_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A072_extra_packed) == 1, "");
_Static_assert(sizeof(struct A072_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A072_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A072_extra_size) == 10, "");
_Static_assert(_Alignof(struct A072_extra_size) == 1, "");
_Static_assert(sizeof(A073) == 8, "");
_Static_assert(_Alignof(A073) == 8, "");
_Static_assert(sizeof(struct A073_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A073_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A073_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A073_extra_packed) == 1, "");
_Static_assert(sizeof(struct A073_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A073_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A073_extra_size) == 10, "");
_Static_assert(_Alignof(struct A073_extra_size) == 1, "");
_Static_assert(sizeof(A074) == 8, "");
_Static_assert(_Alignof(A074) == 8, "");
_Static_assert(sizeof(struct A074_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A074_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A074_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A074_extra_packed) == 1, "");
_Static_assert(sizeof(struct A074_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A074_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A074_extra_size) == 10, "");
_Static_assert(_Alignof(struct A074_extra_size) == 1, "");
_Static_assert(sizeof(A075) == 8, "");
_Static_assert(_Alignof(A075) == 8, "");
_Static_assert(sizeof(struct A075_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A075_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A075_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A075_extra_packed) == 1, "");
_Static_assert(sizeof(struct A075_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A075_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A075_extra_size) == 10, "");
_Static_assert(_Alignof(struct A075_extra_size) == 1, "");
_Static_assert(sizeof(A076) == 8, "");
_Static_assert(_Alignof(A076) == 8, "");
_Static_assert(sizeof(struct A076_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A076_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A076_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A076_extra_packed) == 1, "");
_Static_assert(sizeof(struct A076_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A076_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A076_extra_size) == 10, "");
_Static_assert(_Alignof(struct A076_extra_size) == 1, "");
_Static_assert(sizeof(A081) == 1, "");
_Static_assert(_Alignof(A081) == 1, "");
_Static_assert(sizeof(struct A081_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A081_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A081_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A081_extra_packed) == 1, "");
_Static_assert(sizeof(struct A081_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A081_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A081_extra_size) == 3, "");
_Static_assert(_Alignof(struct A081_extra_size) == 1, "");
_Static_assert(sizeof(A082) == 1, "");
_Static_assert(_Alignof(A082) == 1, "");
_Static_assert(sizeof(struct A082_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A082_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A082_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A082_extra_packed) == 1, "");
_Static_assert(sizeof(struct A082_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A082_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A082_extra_size) == 3, "");
_Static_assert(_Alignof(struct A082_extra_size) == 1, "");
_Static_assert(sizeof(A083) == 1, "");
_Static_assert(_Alignof(A083) == 1, "");
_Static_assert(sizeof(struct A083_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A083_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A083_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A083_extra_packed) == 1, "");
_Static_assert(sizeof(struct A083_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A083_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A083_extra_size) == 3, "");
_Static_assert(_Alignof(struct A083_extra_size) == 1, "");
_Static_assert(sizeof(A084) == 1, "");
_Static_assert(_Alignof(A084) == 1, "");
_Static_assert(sizeof(struct A084_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A084_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A084_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A084_extra_packed) == 1, "");
_Static_assert(sizeof(struct A084_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A084_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A084_extra_size) == 3, "");
_Static_assert(_Alignof(struct A084_extra_size) == 1, "");
_Static_assert(sizeof(A085) == 1, "");
_Static_assert(_Alignof(A085) == 1, "");
_Static_assert(sizeof(struct A085_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A085_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A085_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A085_extra_packed) == 1, "");
_Static_assert(sizeof(struct A085_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A085_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A085_extra_size) == 3, "");
_Static_assert(_Alignof(struct A085_extra_size) == 1, "");
_Static_assert(sizeof(A086) == 1, "");
_Static_assert(_Alignof(A086) == 1, "");
_Static_assert(sizeof(struct A086_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A086_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A086_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A086_extra_packed) == 1, "");
_Static_assert(sizeof(struct A086_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A086_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A086_extra_size) == 3, "");
_Static_assert(_Alignof(struct A086_extra_size) == 1, "");
_Static_assert(sizeof(A087) == 1, "");
_Static_assert(_Alignof(A087) == 1, "");
_Static_assert(sizeof(struct A087_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A087_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A087_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A087_extra_packed) == 1, "");
_Static_assert(sizeof(struct A087_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A087_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A087_extra_size) == 3, "");
_Static_assert(_Alignof(struct A087_extra_size) == 1, "");
_Static_assert(sizeof(A088) == 1, "");
_Static_assert(_Alignof(A088) == 1, "");
_Static_assert(sizeof(struct A088_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A088_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A088_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A088_extra_packed) == 1, "");
_Static_assert(sizeof(struct A088_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A088_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A088_extra_size) == 3, "");
_Static_assert(_Alignof(struct A088_extra_size) == 1, "");
_Static_assert(sizeof(A089) == 2, "");
_Static_assert(_Alignof(A089) == 2, "");
_Static_assert(sizeof(struct A089_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A089_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A089_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A089_extra_packed) == 1, "");
_Static_assert(sizeof(struct A089_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A089_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A089_extra_size) == 4, "");
_Static_assert(_Alignof(struct A089_extra_size) == 1, "");
_Static_assert(sizeof(A090) == 2, "");
_Static_assert(_Alignof(A090) == 2, "");
_Static_assert(sizeof(struct A090_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A090_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A090_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A090_extra_packed) == 1, "");
_Static_assert(sizeof(struct A090_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A090_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A090_extra_size) == 4, "");
_Static_assert(_Alignof(struct A090_extra_size) == 1, "");
_Static_assert(sizeof(A091) == 2, "");
_Static_assert(_Alignof(A091) == 2, "");
_Static_assert(sizeof(struct A091_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A091_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A091_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A091_extra_packed) == 1, "");
_Static_assert(sizeof(struct A091_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A091_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A091_extra_size) == 4, "");
_Static_assert(_Alignof(struct A091_extra_size) == 1, "");
_Static_assert(sizeof(A092) == 2, "");
_Static_assert(_Alignof(A092) == 2, "");
_Static_assert(sizeof(struct A092_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A092_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A092_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A092_extra_packed) == 1, "");
_Static_assert(sizeof(struct A092_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A092_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A092_extra_size) == 4, "");
_Static_assert(_Alignof(struct A092_extra_size) == 1, "");
_Static_assert(sizeof(A093) == 2, "");
_Static_assert(_Alignof(A093) == 2, "");
_Static_assert(sizeof(struct A093_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A093_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A093_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A093_extra_packed) == 1, "");
_Static_assert(sizeof(struct A093_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A093_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A093_extra_size) == 4, "");
_Static_assert(_Alignof(struct A093_extra_size) == 1, "");
_Static_assert(sizeof(A094) == 2, "");
_Static_assert(_Alignof(A094) == 2, "");
_Static_assert(sizeof(struct A094_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A094_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A094_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A094_extra_packed) == 1, "");
_Static_assert(sizeof(struct A094_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A094_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A094_extra_size) == 4, "");
_Static_assert(_Alignof(struct A094_extra_size) == 1, "");
_Static_assert(sizeof(A095) == 2, "");
_Static_assert(_Alignof(A095) == 2, "");
_Static_assert(sizeof(struct A095_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A095_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A095_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A095_extra_packed) == 1, "");
_Static_assert(sizeof(struct A095_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A095_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A095_extra_size) == 4, "");
_Static_assert(_Alignof(struct A095_extra_size) == 1, "");
_Static_assert(sizeof(A096) == 2, "");
_Static_assert(_Alignof(A096) == 2, "");
_Static_assert(sizeof(struct A096_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A096_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A096_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A096_extra_packed) == 1, "");
_Static_assert(sizeof(struct A096_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A096_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A096_extra_size) == 4, "");
_Static_assert(_Alignof(struct A096_extra_size) == 1, "");
_Static_assert(sizeof(A101) == 4, "");
_Static_assert(_Alignof(A101) == 4, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 6, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
_Static_assert(sizeof(A102) == 4, "");
_Static_assert(_Alignof(A102) == 4, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 6, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
_Static_assert(sizeof(A103) == 4, "");
_Static_assert(_Alignof(A103) == 4, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 6, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
_Static_assert(sizeof(A104) == 4, "");
_Static_assert(_Alignof(A104) == 4, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 6, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 4, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
_Static_assert(sizeof(A106) == 4, "");
_Static_assert(_Alignof(A106) == 4, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 6, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
_Static_assert(sizeof(A107) == 4, "");
_Static_assert(_Alignof(A107) == 4, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 6, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
_Static_assert(sizeof(A108) == 4, "");
_Static_assert(_Alignof(A108) == 4, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 6, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
_Static_assert(sizeof(A109) == 4, "");
_Static_assert(_Alignof(A109) == 4, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 6, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
_Static_assert(sizeof(A110) == 4, "");
_Static_assert(_Alignof(A110) == 4, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 6, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
_Static_assert(sizeof(A111) == 4, "");
_Static_assert(_Alignof(A111) == 4, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 6, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
_Static_assert(sizeof(A112) == 4, "");
_Static_assert(_Alignof(A112) == 4, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 6, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
_Static_assert(sizeof(A113) == 4, "");
_Static_assert(_Alignof(A113) == 4, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 6, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
_Static_assert(sizeof(A114) == 4, "");
_Static_assert(_Alignof(A114) == 4, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 6, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
_Static_assert(sizeof(A115) == 4, "");
_Static_assert(_Alignof(A115) == 4, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 6, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
_Static_assert(sizeof(A116) == 4, "");
_Static_assert(_Alignof(A116) == 4, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 6, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
_Static_assert(sizeof(A121) == 8, "");
_Static_assert(_Alignof(A121) == 8, "");
_Static_assert(sizeof(struct A121_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A121_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A121_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A121_extra_packed) == 1, "");
_Static_assert(sizeof(struct A121_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A121_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A121_extra_size) == 10, "");
_Static_assert(_Alignof(struct A121_extra_size) == 1, "");
_Static_assert(sizeof(A122) == 8, "");
_Static_assert(_Alignof(A122) == 8, "");
_Static_assert(sizeof(struct A122_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A122_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A122_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A122_extra_packed) == 1, "");
_Static_assert(sizeof(struct A122_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A122_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A122_extra_size) == 10, "");
_Static_assert(_Alignof(struct A122_extra_size) == 1, "");
_Static_assert(sizeof(A123) == 8, "");
_Static_assert(_Alignof(A123) == 8, "");
_Static_assert(sizeof(struct A123_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A123_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A123_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A123_extra_packed) == 1, "");
_Static_assert(sizeof(struct A123_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A123_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A123_extra_size) == 10, "");
_Static_assert(_Alignof(struct A123_extra_size) == 1, "");
_Static_assert(sizeof(A124) == 8, "");
_Static_assert(_Alignof(A124) == 8, "");
_Static_assert(sizeof(struct A124_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A124_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A124_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A124_extra_packed) == 1, "");
_Static_assert(sizeof(struct A124_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A124_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A124_extra_size) == 10, "");
_Static_assert(_Alignof(struct A124_extra_size) == 1, "");
_Static_assert(sizeof(A125) == 8, "");
_Static_assert(_Alignof(A125) == 8, "");
_Static_assert(sizeof(struct A125_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A125_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A125_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A125_extra_packed) == 1, "");
_Static_assert(sizeof(struct A125_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A125_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A125_extra_size) == 10, "");
_Static_assert(_Alignof(struct A125_extra_size) == 1, "");
_Static_assert(sizeof(A126) == 8, "");
_Static_assert(_Alignof(A126) == 8, "");
_Static_assert(sizeof(struct A126_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A126_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A126_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A126_extra_packed) == 1, "");
_Static_assert(sizeof(struct A126_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A126_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A126_extra_size) == 10, "");
_Static_assert(_Alignof(struct A126_extra_size) == 1, "");
_Static_assert(sizeof(A127) == 8, "");
_Static_assert(_Alignof(A127) == 8, "");
_Static_assert(sizeof(struct A127_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A127_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A127_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A127_extra_packed) == 1, "");
_Static_assert(sizeof(struct A127_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A127_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A127_extra_size) == 10, "");
_Static_assert(_Alignof(struct A127_extra_size) == 1, "");
_Static_assert(sizeof(A128) == 8, "");
_Static_assert(_Alignof(A128) == 8, "");
_Static_assert(sizeof(struct A128_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A128_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A128_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A128_extra_packed) == 1, "");
_Static_assert(sizeof(struct A128_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A128_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A128_extra_size) == 10, "");
_Static_assert(_Alignof(struct A128_extra_size) == 1, "");
_Static_assert(sizeof(A129) == 8, "");
_Static_assert(_Alignof(A129) == 8, "");
_Static_assert(sizeof(struct A129_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A129_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A129_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A129_extra_packed) == 1, "");
_Static_assert(sizeof(struct A129_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A129_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A129_extra_size) == 10, "");
_Static_assert(_Alignof(struct A129_extra_size) == 1, "");
_Static_assert(sizeof(A130) == 8, "");
_Static_assert(_Alignof(A130) == 8, "");
_Static_assert(sizeof(struct A130_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A130_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A130_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A130_extra_packed) == 1, "");
_Static_assert(sizeof(struct A130_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A130_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A130_extra_size) == 10, "");
_Static_assert(_Alignof(struct A130_extra_size) == 1, "");
_Static_assert(sizeof(A131) == 8, "");
_Static_assert(_Alignof(A131) == 8, "");
_Static_assert(sizeof(struct A131_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A131_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A131_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A131_extra_packed) == 1, "");
_Static_assert(sizeof(struct A131_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A131_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A131_extra_size) == 10, "");
_Static_assert(_Alignof(struct A131_extra_size) == 1, "");
_Static_assert(sizeof(A132) == 8, "");
_Static_assert(_Alignof(A132) == 8, "");
_Static_assert(sizeof(struct A132_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A132_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A132_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A132_extra_packed) == 1, "");
_Static_assert(sizeof(struct A132_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A132_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A132_extra_size) == 10, "");
_Static_assert(_Alignof(struct A132_extra_size) == 1, "");
_Static_assert(sizeof(A133) == 8, "");
_Static_assert(_Alignof(A133) == 8, "");
_Static_assert(sizeof(struct A133_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A133_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A133_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A133_extra_packed) == 1, "");
_Static_assert(sizeof(struct A133_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A133_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A133_extra_size) == 10, "");
_Static_assert(_Alignof(struct A133_extra_size) == 1, "");
_Static_assert(sizeof(A134) == 8, "");
_Static_assert(_Alignof(A134) == 8, "");
_Static_assert(sizeof(struct A134_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A134_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A134_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A134_extra_packed) == 1, "");
_Static_assert(sizeof(struct A134_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A134_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A134_extra_size) == 10, "");
_Static_assert(_Alignof(struct A134_extra_size) == 1, "");
_Static_assert(sizeof(A135) == 8, "");
_Static_assert(_Alignof(A135) == 8, "");
_Static_assert(sizeof(struct A135_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A135_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A135_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A135_extra_packed) == 1, "");
_Static_assert(sizeof(struct A135_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A135_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A135_extra_size) == 10, "");
_Static_assert(_Alignof(struct A135_extra_size) == 1, "");
_Static_assert(sizeof(A136) == 8, "");
_Static_assert(_Alignof(A136) == 8, "");
_Static_assert(sizeof(struct A136_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A136_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A136_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A136_extra_packed) == 1, "");
_Static_assert(sizeof(struct A136_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A136_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A136_extra_size) == 10, "");
_Static_assert(_Alignof(struct A136_extra_size) == 1, "");
_Static_assert(sizeof(A141) == 8, "");
_Static_assert(_Alignof(A141) == 8, "");
_Static_assert(sizeof(struct A141_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A141_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A141_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A141_extra_packed) == 1, "");
_Static_assert(sizeof(struct A141_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A141_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A141_extra_size) == 10, "");
_Static_assert(_Alignof(struct A141_extra_size) == 1, "");
_Static_assert(sizeof(A142) == 8, "");
_Static_assert(_Alignof(A142) == 8, "");
_Static_assert(sizeof(struct A142_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A142_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A142_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A142_extra_packed) == 1, "");
_Static_assert(sizeof(struct A142_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A142_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A142_extra_size) == 10, "");
_Static_assert(_Alignof(struct A142_extra_size) == 1, "");
_Static_assert(sizeof(A143) == 8, "");
_Static_assert(_Alignof(A143) == 8, "");
_Static_assert(sizeof(struct A143_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A143_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A143_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A143_extra_packed) == 1, "");
_Static_assert(sizeof(struct A143_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A143_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A143_extra_size) == 10, "");
_Static_assert(_Alignof(struct A143_extra_size) == 1, "");
_Static_assert(sizeof(A144) == 8, "");
_Static_assert(_Alignof(A144) == 8, "");
_Static_assert(sizeof(struct A144_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A144_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A144_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A144_extra_packed) == 1, "");
_Static_assert(sizeof(struct A144_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A144_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A144_extra_size) == 10, "");
_Static_assert(_Alignof(struct A144_extra_size) == 1, "");
_Static_assert(sizeof(A145) == 8, "");
_Static_assert(_Alignof(A145) == 8, "");
_Static_assert(sizeof(struct A145_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A145_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A145_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A145_extra_packed) == 1, "");
_Static_assert(sizeof(struct A145_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A145_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A145_extra_size) == 10, "");
_Static_assert(_Alignof(struct A145_extra_size) == 1, "");
_Static_assert(sizeof(A146) == 8, "");
_Static_assert(_Alignof(A146) == 8, "");
_Static_assert(sizeof(struct A146_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A146_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A146_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A146_extra_packed) == 1, "");
_Static_assert(sizeof(struct A146_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A146_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A146_extra_size) == 10, "");
_Static_assert(_Alignof(struct A146_extra_size) == 1, "");
_Static_assert(sizeof(A147) == 8, "");
_Static_assert(_Alignof(A147) == 8, "");
_Static_assert(sizeof(struct A147_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A147_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A147_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A147_extra_packed) == 1, "");
_Static_assert(sizeof(struct A147_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A147_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A147_extra_size) == 10, "");
_Static_assert(_Alignof(struct A147_extra_size) == 1, "");
_Static_assert(sizeof(A148) == 8, "");
_Static_assert(_Alignof(A148) == 8, "");
_Static_assert(sizeof(struct A148_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A148_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A148_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A148_extra_packed) == 1, "");
_Static_assert(sizeof(struct A148_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A148_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A148_extra_size) == 10, "");
_Static_assert(_Alignof(struct A148_extra_size) == 1, "");
_Static_assert(sizeof(A149) == 8, "");
_Static_assert(_Alignof(A149) == 8, "");
_Static_assert(sizeof(struct A149_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A149_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A149_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A149_extra_packed) == 1, "");
_Static_assert(sizeof(struct A149_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A149_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A149_extra_size) == 10, "");
_Static_assert(_Alignof(struct A149_extra_size) == 1, "");
_Static_assert(sizeof(A150) == 8, "");
_Static_assert(_Alignof(A150) == 8, "");
_Static_assert(sizeof(struct A150_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A150_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A150_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A150_extra_packed) == 1, "");
_Static_assert(sizeof(struct A150_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A150_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A150_extra_size) == 10, "");
_Static_assert(_Alignof(struct A150_extra_size) == 1, "");
_Static_assert(sizeof(A151) == 8, "");
_Static_assert(_Alignof(A151) == 8, "");
_Static_assert(sizeof(struct A151_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A151_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A151_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A151_extra_packed) == 1, "");
_Static_assert(sizeof(struct A151_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A151_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A151_extra_size) == 10, "");
_Static_assert(_Alignof(struct A151_extra_size) == 1, "");
_Static_assert(sizeof(A152) == 8, "");
_Static_assert(_Alignof(A152) == 8, "");
_Static_assert(sizeof(struct A152_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A152_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A152_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A152_extra_packed) == 1, "");
_Static_assert(sizeof(struct A152_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A152_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A152_extra_size) == 10, "");
_Static_assert(_Alignof(struct A152_extra_size) == 1, "");
_Static_assert(sizeof(A153) == 8, "");
_Static_assert(_Alignof(A153) == 8, "");
_Static_assert(sizeof(struct A153_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A153_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A153_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A153_extra_packed) == 1, "");
_Static_assert(sizeof(struct A153_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A153_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A153_extra_size) == 10, "");
_Static_assert(_Alignof(struct A153_extra_size) == 1, "");
_Static_assert(sizeof(A154) == 8, "");
_Static_assert(_Alignof(A154) == 8, "");
_Static_assert(sizeof(struct A154_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A154_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A154_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A154_extra_packed) == 1, "");
_Static_assert(sizeof(struct A154_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A154_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A154_extra_size) == 10, "");
_Static_assert(_Alignof(struct A154_extra_size) == 1, "");
_Static_assert(sizeof(A155) == 8, "");
_Static_assert(_Alignof(A155) == 8, "");
_Static_assert(sizeof(struct A155_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A155_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A155_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A155_extra_packed) == 1, "");
_Static_assert(sizeof(struct A155_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A155_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A155_extra_size) == 10, "");
_Static_assert(_Alignof(struct A155_extra_size) == 1, "");
_Static_assert(sizeof(A156) == 8, "");
_Static_assert(_Alignof(A156) == 8, "");
_Static_assert(sizeof(struct A156_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A156_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A156_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A156_extra_packed) == 1, "");
_Static_assert(sizeof(struct A156_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A156_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A156_extra_size) == 10, "");
_Static_assert(_Alignof(struct A156_extra_size) == 1, "");
_Static_assert(sizeof(B000) == 1, "");
_Static_assert(_Alignof(B000) == 1, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 3, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
_Static_assert(sizeof(B001) == 1, "");
_Static_assert(_Alignof(B001) == 1, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 3, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
_Static_assert(sizeof(B002) == 1, "");
_Static_assert(_Alignof(B002) == 1, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 3, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
_Static_assert(sizeof(B003) == 1, "");
_Static_assert(_Alignof(B003) == 1, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 3, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
_Static_assert(sizeof(B004) == 1, "");
_Static_assert(_Alignof(B004) == 1, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 3, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 1, "");
_Static_assert(_Alignof(B005) == 1, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 3, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
_Static_assert(sizeof(B006) == 1, "");
_Static_assert(_Alignof(B006) == 1, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 3, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
_Static_assert(sizeof(B007) == 1, "");
_Static_assert(_Alignof(B007) == 1, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 3, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
_Static_assert(sizeof(B008) == 1, "");
_Static_assert(_Alignof(B008) == 1, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 3, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
_Static_assert(sizeof(B009) == 2, "");
_Static_assert(_Alignof(B009) == 2, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B009_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 4, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 2, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
_Static_assert(sizeof(B011) == 2, "");
_Static_assert(_Alignof(B011) == 2, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 4, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 2, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
_Static_assert(sizeof(B013) == 2, "");
_Static_assert(_Alignof(B013) == 2, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B013_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 4, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
_Static_assert(sizeof(B014) == 2, "");
_Static_assert(_Alignof(B014) == 2, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B014_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 4, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
_Static_assert(sizeof(B015) == 2, "");
_Static_assert(_Alignof(B015) == 2, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 4, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
_Static_assert(sizeof(B016) == 2, "");
_Static_assert(_Alignof(B016) == 2, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 4, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
_Static_assert(sizeof(B021) == 4, "");
_Static_assert(_Alignof(B021) == 4, "");
_Static_assert(sizeof(struct B021_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B021_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B021_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B021_extra_packed) == 1, "");
_Static_assert(sizeof(struct B021_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B021_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B021_extra_size) == 6, "");
_Static_assert(_Alignof(struct B021_extra_size) == 1, "");
_Static_assert(sizeof(B022) == 4, "");
_Static_assert(_Alignof(B022) == 4, "");
_Static_assert(sizeof(struct B022_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B022_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B022_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B022_extra_packed) == 1, "");
_Static_assert(sizeof(struct B022_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B022_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B022_extra_size) == 6, "");
_Static_assert(_Alignof(struct B022_extra_size) == 1, "");
_Static_assert(sizeof(B023) == 4, "");
_Static_assert(_Alignof(B023) == 4, "");
_Static_assert(sizeof(struct B023_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B023_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B023_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B023_extra_packed) == 1, "");
_Static_assert(sizeof(struct B023_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B023_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B023_extra_size) == 6, "");
_Static_assert(_Alignof(struct B023_extra_size) == 1, "");
_Static_assert(sizeof(B024) == 4, "");
_Static_assert(_Alignof(B024) == 4, "");
_Static_assert(sizeof(struct B024_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B024_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B024_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B024_extra_packed) == 1, "");
_Static_assert(sizeof(struct B024_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B024_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B024_extra_size) == 6, "");
_Static_assert(_Alignof(struct B024_extra_size) == 1, "");
_Static_assert(sizeof(B025) == 4, "");
_Static_assert(_Alignof(B025) == 4, "");
_Static_assert(sizeof(struct B025_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B025_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B025_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B025_extra_packed) == 1, "");
_Static_assert(sizeof(struct B025_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B025_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B025_extra_size) == 6, "");
_Static_assert(_Alignof(struct B025_extra_size) == 1, "");
_Static_assert(sizeof(B026) == 4, "");
_Static_assert(_Alignof(B026) == 4, "");
_Static_assert(sizeof(struct B026_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B026_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B026_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B026_extra_packed) == 1, "");
_Static_assert(sizeof(struct B026_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B026_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B026_extra_size) == 6, "");
_Static_assert(_Alignof(struct B026_extra_size) == 1, "");
_Static_assert(sizeof(B027) == 4, "");
_Static_assert(_Alignof(B027) == 4, "");
_Static_assert(sizeof(struct B027_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B027_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B027_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B027_extra_packed) == 1, "");
_Static_assert(sizeof(struct B027_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B027_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B027_extra_size) == 6, "");
_Static_assert(_Alignof(struct B027_extra_size) == 1, "");
_Static_assert(sizeof(B028) == 4, "");
_Static_assert(_Alignof(B028) == 4, "");
_Static_assert(sizeof(struct B028_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B028_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B028_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B028_extra_packed) == 1, "");
_Static_assert(sizeof(struct B028_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B028_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B028_extra_size) == 6, "");
_Static_assert(_Alignof(struct B028_extra_size) == 1, "");
_Static_assert(sizeof(B029) == 4, "");
_Static_assert(_Alignof(B029) == 4, "");
_Static_assert(sizeof(struct B029_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B029_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B029_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B029_extra_packed) == 1, "");
_Static_assert(sizeof(struct B029_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B029_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B029_extra_size) == 6, "");
_Static_assert(_Alignof(struct B029_extra_size) == 1, "");
_Static_assert(sizeof(B030) == 4, "");
_Static_assert(_Alignof(B030) == 4, "");
_Static_assert(sizeof(struct B030_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B030_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B030_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B030_extra_packed) == 1, "");
_Static_assert(sizeof(struct B030_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B030_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B030_extra_size) == 6, "");
_Static_assert(_Alignof(struct B030_extra_size) == 1, "");
_Static_assert(sizeof(B031) == 4, "");
_Static_assert(_Alignof(B031) == 4, "");
_Static_assert(sizeof(struct B031_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B031_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B031_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B031_extra_packed) == 1, "");
_Static_assert(sizeof(struct B031_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B031_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B031_extra_size) == 6, "");
_Static_assert(_Alignof(struct B031_extra_size) == 1, "");
_Static_assert(sizeof(B032) == 4, "");
_Static_assert(_Alignof(B032) == 4, "");
_Static_assert(sizeof(struct B032_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B032_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B032_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B032_extra_packed) == 1, "");
_Static_assert(sizeof(struct B032_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B032_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B032_extra_size) == 6, "");
_Static_assert(_Alignof(struct B032_extra_size) == 1, "");
_Static_assert(sizeof(B033) == 4, "");
_Static_assert(_Alignof(B033) == 4, "");
_Static_assert(sizeof(struct B033_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B033_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B033_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B033_extra_packed) == 1, "");
_Static_assert(sizeof(struct B033_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B033_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B033_extra_size) == 6, "");
_Static_assert(_Alignof(struct B033_extra_size) == 1, "");
_Static_assert(sizeof(B034) == 4, "");
_Static_assert(_Alignof(B034) == 4, "");
_Static_assert(sizeof(struct B034_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B034_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B034_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B034_extra_packed) == 1, "");
_Static_assert(sizeof(struct B034_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B034_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B034_extra_size) == 6, "");
_Static_assert(_Alignof(struct B034_extra_size) == 1, "");
_Static_assert(sizeof(B035) == 4, "");
_Static_assert(_Alignof(B035) == 4, "");
_Static_assert(sizeof(struct B035_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B035_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B035_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B035_extra_packed) == 1, "");
_Static_assert(sizeof(struct B035_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B035_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B035_extra_size) == 6, "");
_Static_assert(_Alignof(struct B035_extra_size) == 1, "");
_Static_assert(sizeof(B036) == 4, "");
_Static_assert(_Alignof(B036) == 4, "");
_Static_assert(sizeof(struct B036_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B036_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B036_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B036_extra_packed) == 1, "");
_Static_assert(sizeof(struct B036_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B036_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B036_extra_size) == 6, "");
_Static_assert(_Alignof(struct B036_extra_size) == 1, "");
_Static_assert(sizeof(B041) == 8, "");
_Static_assert(_Alignof(B041) == 8, "");
_Static_assert(sizeof(struct B041_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B041_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B041_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B041_extra_packed) == 1, "");
_Static_assert(sizeof(struct B041_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B041_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B041_extra_size) == 10, "");
_Static_assert(_Alignof(struct B041_extra_size) == 1, "");
_Static_assert(sizeof(B042) == 8, "");
_Static_assert(_Alignof(B042) == 8, "");
_Static_assert(sizeof(struct B042_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B042_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B042_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B042_extra_packed) == 1, "");
_Static_assert(sizeof(struct B042_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B042_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B042_extra_size) == 10, "");
_Static_assert(_Alignof(struct B042_extra_size) == 1, "");
_Static_assert(sizeof(B043) == 8, "");
_Static_assert(_Alignof(B043) == 8, "");
_Static_assert(sizeof(struct B043_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B043_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B043_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B043_extra_packed) == 1, "");
_Static_assert(sizeof(struct B043_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B043_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B043_extra_size) == 10, "");
_Static_assert(_Alignof(struct B043_extra_size) == 1, "");
_Static_assert(sizeof(B044) == 8, "");
_Static_assert(_Alignof(B044) == 8, "");
_Static_assert(sizeof(struct B044_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B044_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B044_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B044_extra_packed) == 1, "");
_Static_assert(sizeof(struct B044_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B044_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B044_extra_size) == 10, "");
_Static_assert(_Alignof(struct B044_extra_size) == 1, "");
_Static_assert(sizeof(B045) == 8, "");
_Static_assert(_Alignof(B045) == 8, "");
_Static_assert(sizeof(struct B045_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B045_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B045_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B045_extra_packed) == 1, "");
_Static_assert(sizeof(struct B045_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B045_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B045_extra_size) == 10, "");
_Static_assert(_Alignof(struct B045_extra_size) == 1, "");
_Static_assert(sizeof(B046) == 8, "");
_Static_assert(_Alignof(B046) == 8, "");
_Static_assert(sizeof(struct B046_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B046_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B046_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B046_extra_packed) == 1, "");
_Static_assert(sizeof(struct B046_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B046_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B046_extra_size) == 10, "");
_Static_assert(_Alignof(struct B046_extra_size) == 1, "");
_Static_assert(sizeof(B047) == 8, "");
_Static_assert(_Alignof(B047) == 8, "");
_Static_assert(sizeof(struct B047_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B047_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B047_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B047_extra_packed) == 1, "");
_Static_assert(sizeof(struct B047_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B047_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B047_extra_size) == 10, "");
_Static_assert(_Alignof(struct B047_extra_size) == 1, "");
_Static_assert(sizeof(B048) == 8, "");
_Static_assert(_Alignof(B048) == 8, "");
_Static_assert(sizeof(struct B048_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B048_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B048_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B048_extra_packed) == 1, "");
_Static_assert(sizeof(struct B048_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B048_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B048_extra_size) == 10, "");
_Static_assert(_Alignof(struct B048_extra_size) == 1, "");
_Static_assert(sizeof(B049) == 8, "");
_Static_assert(_Alignof(B049) == 8, "");
_Static_assert(sizeof(struct B049_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B049_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B049_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B049_extra_packed) == 1, "");
_Static_assert(sizeof(struct B049_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B049_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B049_extra_size) == 10, "");
_Static_assert(_Alignof(struct B049_extra_size) == 1, "");
_Static_assert(sizeof(B050) == 8, "");
_Static_assert(_Alignof(B050) == 8, "");
_Static_assert(sizeof(struct B050_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B050_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B050_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B050_extra_packed) == 1, "");
_Static_assert(sizeof(struct B050_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B050_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B050_extra_size) == 10, "");
_Static_assert(_Alignof(struct B050_extra_size) == 1, "");
_Static_assert(sizeof(B051) == 8, "");
_Static_assert(_Alignof(B051) == 8, "");
_Static_assert(sizeof(struct B051_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B051_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B051_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B051_extra_packed) == 1, "");
_Static_assert(sizeof(struct B051_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B051_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B051_extra_size) == 10, "");
_Static_assert(_Alignof(struct B051_extra_size) == 1, "");
_Static_assert(sizeof(B052) == 8, "");
_Static_assert(_Alignof(B052) == 8, "");
_Static_assert(sizeof(struct B052_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B052_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B052_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B052_extra_packed) == 1, "");
_Static_assert(sizeof(struct B052_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B052_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B052_extra_size) == 10, "");
_Static_assert(_Alignof(struct B052_extra_size) == 1, "");
_Static_assert(sizeof(B053) == 8, "");
_Static_assert(_Alignof(B053) == 8, "");
_Static_assert(sizeof(struct B053_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B053_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B053_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B053_extra_packed) == 1, "");
_Static_assert(sizeof(struct B053_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B053_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B053_extra_size) == 10, "");
_Static_assert(_Alignof(struct B053_extra_size) == 1, "");
_Static_assert(sizeof(B054) == 8, "");
_Static_assert(_Alignof(B054) == 8, "");
_Static_assert(sizeof(struct B054_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B054_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B054_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B054_extra_packed) == 1, "");
_Static_assert(sizeof(struct B054_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B054_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B054_extra_size) == 10, "");
_Static_assert(_Alignof(struct B054_extra_size) == 1, "");
_Static_assert(sizeof(B055) == 8, "");
_Static_assert(_Alignof(B055) == 8, "");
_Static_assert(sizeof(struct B055_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B055_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B055_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B055_extra_packed) == 1, "");
_Static_assert(sizeof(struct B055_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B055_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B055_extra_size) == 10, "");
_Static_assert(_Alignof(struct B055_extra_size) == 1, "");
_Static_assert(sizeof(B056) == 8, "");
_Static_assert(_Alignof(B056) == 8, "");
_Static_assert(sizeof(struct B056_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B056_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B056_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B056_extra_packed) == 1, "");
_Static_assert(sizeof(struct B056_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B056_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B056_extra_size) == 10, "");
_Static_assert(_Alignof(struct B056_extra_size) == 1, "");
_Static_assert(sizeof(B061) == 8, "");
_Static_assert(_Alignof(B061) == 8, "");
_Static_assert(sizeof(struct B061_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B061_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B061_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B061_extra_packed) == 1, "");
_Static_assert(sizeof(struct B061_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B061_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B061_extra_size) == 10, "");
_Static_assert(_Alignof(struct B061_extra_size) == 1, "");
_Static_assert(sizeof(B062) == 8, "");
_Static_assert(_Alignof(B062) == 8, "");
_Static_assert(sizeof(struct B062_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B062_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B062_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B062_extra_packed) == 1, "");
_Static_assert(sizeof(struct B062_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B062_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B062_extra_size) == 10, "");
_Static_assert(_Alignof(struct B062_extra_size) == 1, "");
_Static_assert(sizeof(B063) == 8, "");
_Static_assert(_Alignof(B063) == 8, "");
_Static_assert(sizeof(struct B063_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B063_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B063_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B063_extra_packed) == 1, "");
_Static_assert(sizeof(struct B063_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B063_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B063_extra_size) == 10, "");
_Static_assert(_Alignof(struct B063_extra_size) == 1, "");
_Static_assert(sizeof(B064) == 8, "");
_Static_assert(_Alignof(B064) == 8, "");
_Static_assert(sizeof(struct B064_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B064_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B064_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B064_extra_packed) == 1, "");
_Static_assert(sizeof(struct B064_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B064_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B064_extra_size) == 10, "");
_Static_assert(_Alignof(struct B064_extra_size) == 1, "");
_Static_assert(sizeof(B065) == 8, "");
_Static_assert(_Alignof(B065) == 8, "");
_Static_assert(sizeof(struct B065_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B065_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B065_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B065_extra_packed) == 1, "");
_Static_assert(sizeof(struct B065_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B065_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B065_extra_size) == 10, "");
_Static_assert(_Alignof(struct B065_extra_size) == 1, "");
_Static_assert(sizeof(B066) == 8, "");
_Static_assert(_Alignof(B066) == 8, "");
_Static_assert(sizeof(struct B066_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B066_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B066_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B066_extra_packed) == 1, "");
_Static_assert(sizeof(struct B066_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B066_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B066_extra_size) == 10, "");
_Static_assert(_Alignof(struct B066_extra_size) == 1, "");
_Static_assert(sizeof(B067) == 8, "");
_Static_assert(_Alignof(B067) == 8, "");
_Static_assert(sizeof(struct B067_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B067_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B067_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B067_extra_packed) == 1, "");
_Static_assert(sizeof(struct B067_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B067_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B067_extra_size) == 10, "");
_Static_assert(_Alignof(struct B067_extra_size) == 1, "");
_Static_assert(sizeof(B068) == 8, "");
_Static_assert(_Alignof(B068) == 8, "");
_Static_assert(sizeof(struct B068_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B068_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B068_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B068_extra_packed) == 1, "");
_Static_assert(sizeof(struct B068_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B068_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B068_extra_size) == 10, "");
_Static_assert(_Alignof(struct B068_extra_size) == 1, "");
_Static_assert(sizeof(B069) == 8, "");
_Static_assert(_Alignof(B069) == 8, "");
_Static_assert(sizeof(struct B069_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B069_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B069_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B069_extra_packed) == 1, "");
_Static_assert(sizeof(struct B069_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B069_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B069_extra_size) == 10, "");
_Static_assert(_Alignof(struct B069_extra_size) == 1, "");
_Static_assert(sizeof(B070) == 8, "");
_Static_assert(_Alignof(B070) == 8, "");
_Static_assert(sizeof(struct B070_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B070_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B070_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B070_extra_packed) == 1, "");
_Static_assert(sizeof(struct B070_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B070_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B070_extra_size) == 10, "");
_Static_assert(_Alignof(struct B070_extra_size) == 1, "");
_Static_assert(sizeof(B071) == 8, "");
_Static_assert(_Alignof(B071) == 8, "");
_Static_assert(sizeof(struct B071_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B071_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B071_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B071_extra_packed) == 1, "");
_Static_assert(sizeof(struct B071_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B071_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B071_extra_size) == 10, "");
_Static_assert(_Alignof(struct B071_extra_size) == 1, "");
_Static_assert(sizeof(B072) == 8, "");
_Static_assert(_Alignof(B072) == 8, "");
_Static_assert(sizeof(struct B072_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B072_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B072_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B072_extra_packed) == 1, "");
_Static_assert(sizeof(struct B072_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B072_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B072_extra_size) == 10, "");
_Static_assert(_Alignof(struct B072_extra_size) == 1, "");
_Static_assert(sizeof(B073) == 8, "");
_Static_assert(_Alignof(B073) == 8, "");
_Static_assert(sizeof(struct B073_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B073_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B073_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B073_extra_packed) == 1, "");
_Static_assert(sizeof(struct B073_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B073_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B073_extra_size) == 10, "");
_Static_assert(_Alignof(struct B073_extra_size) == 1, "");
_Static_assert(sizeof(B074) == 8, "");
_Static_assert(_Alignof(B074) == 8, "");
_Static_assert(sizeof(struct B074_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B074_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B074_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B074_extra_packed) == 1, "");
_Static_assert(sizeof(struct B074_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B074_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B074_extra_size) == 10, "");
_Static_assert(_Alignof(struct B074_extra_size) == 1, "");
_Static_assert(sizeof(B075) == 8, "");
_Static_assert(_Alignof(B075) == 8, "");
_Static_assert(sizeof(struct B075_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B075_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B075_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B075_extra_packed) == 1, "");
_Static_assert(sizeof(struct B075_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B075_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B075_extra_size) == 10, "");
_Static_assert(_Alignof(struct B075_extra_size) == 1, "");
_Static_assert(sizeof(B076) == 8, "");
_Static_assert(_Alignof(B076) == 8, "");
_Static_assert(sizeof(struct B076_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B076_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B076_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B076_extra_packed) == 1, "");
_Static_assert(sizeof(struct B076_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B076_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B076_extra_size) == 10, "");
_Static_assert(_Alignof(struct B076_extra_size) == 1, "");
_Static_assert(sizeof(B081) == 1, "");
_Static_assert(_Alignof(B081) == 1, "");
_Static_assert(sizeof(struct B081_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B081_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B081_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B081_extra_packed) == 1, "");
_Static_assert(sizeof(struct B081_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B081_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B081_extra_size) == 3, "");
_Static_assert(_Alignof(struct B081_extra_size) == 1, "");
_Static_assert(sizeof(B082) == 1, "");
_Static_assert(_Alignof(B082) == 1, "");
_Static_assert(sizeof(struct B082_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B082_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B082_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B082_extra_packed) == 1, "");
_Static_assert(sizeof(struct B082_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B082_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B082_extra_size) == 3, "");
_Static_assert(_Alignof(struct B082_extra_size) == 1, "");
_Static_assert(sizeof(B083) == 1, "");
_Static_assert(_Alignof(B083) == 1, "");
_Static_assert(sizeof(struct B083_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B083_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B083_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B083_extra_packed) == 1, "");
_Static_assert(sizeof(struct B083_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B083_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B083_extra_size) == 3, "");
_Static_assert(_Alignof(struct B083_extra_size) == 1, "");
_Static_assert(sizeof(B084) == 1, "");
_Static_assert(_Alignof(B084) == 1, "");
_Static_assert(sizeof(struct B084_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B084_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B084_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B084_extra_packed) == 1, "");
_Static_assert(sizeof(struct B084_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B084_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B084_extra_size) == 3, "");
_Static_assert(_Alignof(struct B084_extra_size) == 1, "");
_Static_assert(sizeof(B085) == 1, "");
_Static_assert(_Alignof(B085) == 1, "");
_Static_assert(sizeof(struct B085_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B085_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B085_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B085_extra_packed) == 1, "");
_Static_assert(sizeof(struct B085_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B085_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B085_extra_size) == 3, "");
_Static_assert(_Alignof(struct B085_extra_size) == 1, "");
_Static_assert(sizeof(B086) == 1, "");
_Static_assert(_Alignof(B086) == 1, "");
_Static_assert(sizeof(struct B086_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B086_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B086_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B086_extra_packed) == 1, "");
_Static_assert(sizeof(struct B086_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B086_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B086_extra_size) == 3, "");
_Static_assert(_Alignof(struct B086_extra_size) == 1, "");
_Static_assert(sizeof(B087) == 1, "");
_Static_assert(_Alignof(B087) == 1, "");
_Static_assert(sizeof(struct B087_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B087_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B087_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B087_extra_packed) == 1, "");
_Static_assert(sizeof(struct B087_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B087_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B087_extra_size) == 3, "");
_Static_assert(_Alignof(struct B087_extra_size) == 1, "");
_Static_assert(sizeof(B088) == 1, "");
_Static_assert(_Alignof(B088) == 1, "");
_Static_assert(sizeof(struct B088_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B088_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B088_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B088_extra_packed) == 1, "");
_Static_assert(sizeof(struct B088_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B088_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B088_extra_size) == 3, "");
_Static_assert(_Alignof(struct B088_extra_size) == 1, "");
_Static_assert(sizeof(B089) == 2, "");
_Static_assert(_Alignof(B089) == 2, "");
_Static_assert(sizeof(struct B089_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B089_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B089_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B089_extra_packed) == 1, "");
_Static_assert(sizeof(struct B089_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B089_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B089_extra_size) == 4, "");
_Static_assert(_Alignof(struct B089_extra_size) == 1, "");
_Static_assert(sizeof(B090) == 2, "");
_Static_assert(_Alignof(B090) == 2, "");
_Static_assert(sizeof(struct B090_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B090_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B090_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B090_extra_packed) == 1, "");
_Static_assert(sizeof(struct B090_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B090_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B090_extra_size) == 4, "");
_Static_assert(_Alignof(struct B090_extra_size) == 1, "");
_Static_assert(sizeof(B091) == 2, "");
_Static_assert(_Alignof(B091) == 2, "");
_Static_assert(sizeof(struct B091_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B091_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B091_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B091_extra_packed) == 1, "");
_Static_assert(sizeof(struct B091_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B091_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B091_extra_size) == 4, "");
_Static_assert(_Alignof(struct B091_extra_size) == 1, "");
_Static_assert(sizeof(B092) == 2, "");
_Static_assert(_Alignof(B092) == 2, "");
_Static_assert(sizeof(struct B092_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B092_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B092_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B092_extra_packed) == 1, "");
_Static_assert(sizeof(struct B092_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B092_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B092_extra_size) == 4, "");
_Static_assert(_Alignof(struct B092_extra_size) == 1, "");
_Static_assert(sizeof(B093) == 2, "");
_Static_assert(_Alignof(B093) == 2, "");
_Static_assert(sizeof(struct B093_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B093_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B093_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B093_extra_packed) == 1, "");
_Static_assert(sizeof(struct B093_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B093_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B093_extra_size) == 4, "");
_Static_assert(_Alignof(struct B093_extra_size) == 1, "");
_Static_assert(sizeof(B094) == 2, "");
_Static_assert(_Alignof(B094) == 2, "");
_Static_assert(sizeof(struct B094_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B094_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B094_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B094_extra_packed) == 1, "");
_Static_assert(sizeof(struct B094_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B094_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B094_extra_size) == 4, "");
_Static_assert(_Alignof(struct B094_extra_size) == 1, "");
_Static_assert(sizeof(B095) == 2, "");
_Static_assert(_Alignof(B095) == 2, "");
_Static_assert(sizeof(struct B095_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B095_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B095_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B095_extra_packed) == 1, "");
_Static_assert(sizeof(struct B095_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B095_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B095_extra_size) == 4, "");
_Static_assert(_Alignof(struct B095_extra_size) == 1, "");
_Static_assert(sizeof(B096) == 2, "");
_Static_assert(_Alignof(B096) == 2, "");
_Static_assert(sizeof(struct B096_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B096_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B096_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B096_extra_packed) == 1, "");
_Static_assert(sizeof(struct B096_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B096_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B096_extra_size) == 4, "");
_Static_assert(_Alignof(struct B096_extra_size) == 1, "");
_Static_assert(sizeof(B101) == 4, "");
_Static_assert(_Alignof(B101) == 4, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 6, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
_Static_assert(sizeof(B102) == 4, "");
_Static_assert(_Alignof(B102) == 4, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 6, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 4, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 4, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 4, "");
_Static_assert(_Alignof(B105) == 4, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 6, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
_Static_assert(sizeof(B106) == 4, "");
_Static_assert(_Alignof(B106) == 4, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 6, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
_Static_assert(sizeof(B107) == 4, "");
_Static_assert(_Alignof(B107) == 4, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 6, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 4, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
_Static_assert(sizeof(B109) == 4, "");
_Static_assert(_Alignof(B109) == 4, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 6, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 4, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 4, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 4, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 4, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 4, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 4, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 4, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
_Static_assert(sizeof(B121) == 8, "");
_Static_assert(_Alignof(B121) == 8, "");
_Static_assert(sizeof(struct B121_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B121_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B121_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B121_extra_packed) == 1, "");
_Static_assert(sizeof(struct B121_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B121_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B121_extra_size) == 10, "");
_Static_assert(_Alignof(struct B121_extra_size) == 1, "");
_Static_assert(sizeof(B122) == 8, "");
_Static_assert(_Alignof(B122) == 8, "");
_Static_assert(sizeof(struct B122_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B122_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B122_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B122_extra_packed) == 1, "");
_Static_assert(sizeof(struct B122_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B122_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B122_extra_size) == 10, "");
_Static_assert(_Alignof(struct B122_extra_size) == 1, "");
_Static_assert(sizeof(B123) == 8, "");
_Static_assert(_Alignof(B123) == 8, "");
_Static_assert(sizeof(struct B123_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B123_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B123_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B123_extra_packed) == 1, "");
_Static_assert(sizeof(struct B123_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B123_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B123_extra_size) == 10, "");
_Static_assert(_Alignof(struct B123_extra_size) == 1, "");
_Static_assert(sizeof(B124) == 8, "");
_Static_assert(_Alignof(B124) == 8, "");
_Static_assert(sizeof(struct B124_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B124_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B124_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B124_extra_packed) == 1, "");
_Static_assert(sizeof(struct B124_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B124_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B124_extra_size) == 10, "");
_Static_assert(_Alignof(struct B124_extra_size) == 1, "");
_Static_assert(sizeof(B125) == 8, "");
_Static_assert(_Alignof(B125) == 8, "");
_Static_assert(sizeof(struct B125_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B125_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B125_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B125_extra_packed) == 1, "");
_Static_assert(sizeof(struct B125_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B125_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B125_extra_size) == 10, "");
_Static_assert(_Alignof(struct B125_extra_size) == 1, "");
_Static_assert(sizeof(B126) == 8, "");
_Static_assert(_Alignof(B126) == 8, "");
_Static_assert(sizeof(struct B126_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B126_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B126_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B126_extra_packed) == 1, "");
_Static_assert(sizeof(struct B126_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B126_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B126_extra_size) == 10, "");
_Static_assert(_Alignof(struct B126_extra_size) == 1, "");
_Static_assert(sizeof(B127) == 8, "");
_Static_assert(_Alignof(B127) == 8, "");
_Static_assert(sizeof(struct B127_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B127_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B127_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B127_extra_packed) == 1, "");
_Static_assert(sizeof(struct B127_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B127_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B127_extra_size) == 10, "");
_Static_assert(_Alignof(struct B127_extra_size) == 1, "");
_Static_assert(sizeof(B128) == 8, "");
_Static_assert(_Alignof(B128) == 8, "");
_Static_assert(sizeof(struct B128_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B128_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B128_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B128_extra_packed) == 1, "");
_Static_assert(sizeof(struct B128_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B128_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B128_extra_size) == 10, "");
_Static_assert(_Alignof(struct B128_extra_size) == 1, "");
_Static_assert(sizeof(B129) == 8, "");
_Static_assert(_Alignof(B129) == 8, "");
_Static_assert(sizeof(struct B129_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B129_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B129_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B129_extra_packed) == 1, "");
_Static_assert(sizeof(struct B129_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B129_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B129_extra_size) == 10, "");
_Static_assert(_Alignof(struct B129_extra_size) == 1, "");
_Static_assert(sizeof(B130) == 8, "");
_Static_assert(_Alignof(B130) == 8, "");
_Static_assert(sizeof(struct B130_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B130_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B130_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B130_extra_packed) == 1, "");
_Static_assert(sizeof(struct B130_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B130_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B130_extra_size) == 10, "");
_Static_assert(_Alignof(struct B130_extra_size) == 1, "");
_Static_assert(sizeof(B131) == 8, "");
_Static_assert(_Alignof(B131) == 8, "");
_Static_assert(sizeof(struct B131_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B131_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B131_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B131_extra_packed) == 1, "");
_Static_assert(sizeof(struct B131_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B131_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B131_extra_size) == 10, "");
_Static_assert(_Alignof(struct B131_extra_size) == 1, "");
_Static_assert(sizeof(B132) == 8, "");
_Static_assert(_Alignof(B132) == 8, "");
_Static_assert(sizeof(struct B132_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B132_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B132_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B132_extra_packed) == 1, "");
_Static_assert(sizeof(struct B132_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B132_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B132_extra_size) == 10, "");
_Static_assert(_Alignof(struct B132_extra_size) == 1, "");
_Static_assert(sizeof(B133) == 8, "");
_Static_assert(_Alignof(B133) == 8, "");
_Static_assert(sizeof(struct B133_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B133_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B133_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B133_extra_packed) == 1, "");
_Static_assert(sizeof(struct B133_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B133_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B133_extra_size) == 10, "");
_Static_assert(_Alignof(struct B133_extra_size) == 1, "");
_Static_assert(sizeof(B134) == 8, "");
_Static_assert(_Alignof(B134) == 8, "");
_Static_assert(sizeof(struct B134_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B134_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B134_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B134_extra_packed) == 1, "");
_Static_assert(sizeof(struct B134_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B134_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B134_extra_size) == 10, "");
_Static_assert(_Alignof(struct B134_extra_size) == 1, "");
_Static_assert(sizeof(B135) == 8, "");
_Static_assert(_Alignof(B135) == 8, "");
_Static_assert(sizeof(struct B135_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B135_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B135_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B135_extra_packed) == 1, "");
_Static_assert(sizeof(struct B135_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B135_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B135_extra_size) == 10, "");
_Static_assert(_Alignof(struct B135_extra_size) == 1, "");
_Static_assert(sizeof(B136) == 8, "");
_Static_assert(_Alignof(B136) == 8, "");
_Static_assert(sizeof(struct B136_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B136_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B136_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B136_extra_packed) == 1, "");
_Static_assert(sizeof(struct B136_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B136_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B136_extra_size) == 10, "");
_Static_assert(_Alignof(struct B136_extra_size) == 1, "");
_Static_assert(sizeof(B141) == 8, "");
_Static_assert(_Alignof(B141) == 8, "");
_Static_assert(sizeof(struct B141_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B141_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B141_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B141_extra_packed) == 1, "");
_Static_assert(sizeof(struct B141_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B141_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B141_extra_size) == 10, "");
_Static_assert(_Alignof(struct B141_extra_size) == 1, "");
_Static_assert(sizeof(B142) == 8, "");
_Static_assert(_Alignof(B142) == 8, "");
_Static_assert(sizeof(struct B142_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B142_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B142_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B142_extra_packed) == 1, "");
_Static_assert(sizeof(struct B142_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B142_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B142_extra_size) == 10, "");
_Static_assert(_Alignof(struct B142_extra_size) == 1, "");
_Static_assert(sizeof(B143) == 8, "");
_Static_assert(_Alignof(B143) == 8, "");
_Static_assert(sizeof(struct B143_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B143_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B143_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B143_extra_packed) == 1, "");
_Static_assert(sizeof(struct B143_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B143_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B143_extra_size) == 10, "");
_Static_assert(_Alignof(struct B143_extra_size) == 1, "");
_Static_assert(sizeof(B144) == 8, "");
_Static_assert(_Alignof(B144) == 8, "");
_Static_assert(sizeof(struct B144_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B144_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B144_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B144_extra_packed) == 1, "");
_Static_assert(sizeof(struct B144_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B144_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B144_extra_size) == 10, "");
_Static_assert(_Alignof(struct B144_extra_size) == 1, "");
_Static_assert(sizeof(B145) == 8, "");
_Static_assert(_Alignof(B145) == 8, "");
_Static_assert(sizeof(struct B145_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B145_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B145_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B145_extra_packed) == 1, "");
_Static_assert(sizeof(struct B145_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B145_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B145_extra_size) == 10, "");
_Static_assert(_Alignof(struct B145_extra_size) == 1, "");
_Static_assert(sizeof(B146) == 8, "");
_Static_assert(_Alignof(B146) == 8, "");
_Static_assert(sizeof(struct B146_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B146_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B146_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B146_extra_packed) == 1, "");
_Static_assert(sizeof(struct B146_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B146_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B146_extra_size) == 10, "");
_Static_assert(_Alignof(struct B146_extra_size) == 1, "");
_Static_assert(sizeof(B147) == 8, "");
_Static_assert(_Alignof(B147) == 8, "");
_Static_assert(sizeof(struct B147_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B147_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B147_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B147_extra_packed) == 1, "");
_Static_assert(sizeof(struct B147_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B147_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B147_extra_size) == 10, "");
_Static_assert(_Alignof(struct B147_extra_size) == 1, "");
_Static_assert(sizeof(B148) == 8, "");
_Static_assert(_Alignof(B148) == 8, "");
_Static_assert(sizeof(struct B148_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B148_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B148_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B148_extra_packed) == 1, "");
_Static_assert(sizeof(struct B148_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B148_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B148_extra_size) == 10, "");
_Static_assert(_Alignof(struct B148_extra_size) == 1, "");
_Static_assert(sizeof(B149) == 8, "");
_Static_assert(_Alignof(B149) == 8, "");
_Static_assert(sizeof(struct B149_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B149_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B149_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B149_extra_packed) == 1, "");
_Static_assert(sizeof(struct B149_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B149_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B149_extra_size) == 10, "");
_Static_assert(_Alignof(struct B149_extra_size) == 1, "");
_Static_assert(sizeof(B150) == 8, "");
_Static_assert(_Alignof(B150) == 8, "");
_Static_assert(sizeof(struct B150_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B150_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B150_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B150_extra_packed) == 1, "");
_Static_assert(sizeof(struct B150_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B150_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B150_extra_size) == 10, "");
_Static_assert(_Alignof(struct B150_extra_size) == 1, "");
_Static_assert(sizeof(B151) == 8, "");
_Static_assert(_Alignof(B151) == 8, "");
_Static_assert(sizeof(struct B151_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B151_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B151_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B151_extra_packed) == 1, "");
_Static_assert(sizeof(struct B151_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B151_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B151_extra_size) == 10, "");
_Static_assert(_Alignof(struct B151_extra_size) == 1, "");
_Static_assert(sizeof(B152) == 8, "");
_Static_assert(_Alignof(B152) == 8, "");
_Static_assert(sizeof(struct B152_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B152_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B152_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B152_extra_packed) == 1, "");
_Static_assert(sizeof(struct B152_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B152_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B152_extra_size) == 10, "");
_Static_assert(_Alignof(struct B152_extra_size) == 1, "");
_Static_assert(sizeof(B153) == 8, "");
_Static_assert(_Alignof(B153) == 8, "");
_Static_assert(sizeof(struct B153_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B153_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B153_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B153_extra_packed) == 1, "");
_Static_assert(sizeof(struct B153_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B153_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B153_extra_size) == 10, "");
_Static_assert(_Alignof(struct B153_extra_size) == 1, "");
_Static_assert(sizeof(B154) == 8, "");
_Static_assert(_Alignof(B154) == 8, "");
_Static_assert(sizeof(struct B154_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B154_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B154_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B154_extra_packed) == 1, "");
_Static_assert(sizeof(struct B154_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B154_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B154_extra_size) == 10, "");
_Static_assert(_Alignof(struct B154_extra_size) == 1, "");
_Static_assert(sizeof(B155) == 8, "");
_Static_assert(_Alignof(B155) == 8, "");
_Static_assert(sizeof(struct B155_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B155_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B155_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B155_extra_packed) == 1, "");
_Static_assert(sizeof(struct B155_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B155_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B155_extra_size) == 10, "");
_Static_assert(_Alignof(struct B155_extra_size) == 1, "");
_Static_assert(sizeof(B156) == 8, "");
_Static_assert(_Alignof(B156) == 8, "");
_Static_assert(sizeof(struct B156_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B156_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B156_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B156_extra_packed) == 1, "");
_Static_assert(sizeof(struct B156_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B156_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B156_extra_size) == 10, "");
_Static_assert(_Alignof(struct B156_extra_size) == 1, "");
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A000) == 1, "");
_Static_assert(_Alignof(A000) == 1, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 3, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
_Static_assert(sizeof(A001) == 1, "");
_Static_assert(_Alignof(A001) == 1, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 3, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
_Static_assert(sizeof(A002) == 1, "");
_Static_assert(_Alignof(A002) == 1, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 3, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
_Static_assert(sizeof(A003) == 1, "");
_Static_assert(_Alignof(A003) == 1, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 3, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
_Static_assert(sizeof(A004) == 1, "");
_Static_assert(_Alignof(A004) == 1, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 3, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 1, "");
_Static_assert(_Alignof(A005) == 1, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 3, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
_Static_assert(sizeof(A006) == 1, "");
_Static_assert(_Alignof(A006) == 1, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 3, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
_Static_assert(sizeof(A007) == 1, "");
_Static_assert(_Alignof(A007) == 1, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 3, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
_Static_assert(sizeof(A008) == 1, "");
_Static_assert(_Alignof(A008) == 1, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 3, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
_Static_assert(sizeof(A009) == 2, "");
_Static_assert(_Alignof(A009) == 2, "");
_Static_assert(sizeof(struct A009_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A009_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A009_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A009_extra_packed) == 1, "");
_Static_assert(sizeof(struct A009_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A009_extra_size) == 4, "");
_Static_assert(_Alignof(struct A009_extra_size) == 1, "");
_Static_assert(sizeof(A010) == 2, "");
_Static_assert(_Alignof(A010) == 2, "");
_Static_assert(sizeof(struct A010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A010_extra_packed) == 1, "");
_Static_assert(sizeof(struct A010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A010_extra_size) == 4, "");
_Static_assert(_Alignof(struct A010_extra_size) == 1, "");
_Static_assert(sizeof(A011) == 2, "");
_Static_assert(_Alignof(A011) == 2, "");
_Static_assert(sizeof(struct A011_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A011_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A011_extra_packed) == 1, "");
_Static_assert(sizeof(struct A011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A011_extra_size) == 4, "");
_Static_assert(_Alignof(struct A011_extra_size) == 1, "");
_Static_assert(sizeof(A012) == 2, "");
_Static_assert(_Alignof(A012) == 2, "");
_Static_assert(sizeof(struct A012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A012_extra_packed) == 1, "");
_Static_assert(sizeof(struct A012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A012_extra_size) == 4, "");
_Static_assert(_Alignof(struct A012_extra_size) == 1, "");
_Static_assert(sizeof(A013) == 2, "");
_Static_assert(_Alignof(A013) == 2, "");
_Static_assert(sizeof(struct A013_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A013_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A013_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A013_extra_packed) == 1, "");
_Static_assert(sizeof(struct A013_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A013_extra_size) == 4, "");
_Static_assert(_Alignof(struct A013_extra_size) == 1, "");
_Static_assert(sizeof(A014) == 2, "");
_Static_assert(_Alignof(A014) == 2, "");
_Static_assert(sizeof(struct A014_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A014_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A014_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A014_extra_packed) == 1, "");
_Static_assert(sizeof(struct A014_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A014_extra_size) == 4, "");
_Static_assert(_Alignof(struct A014_extra_size) == 1, "");
_Static_assert(sizeof(A015) == 2, "");
_Static_assert(_Alignof(A015) == 2, "");
_Static_assert(sizeof(struct A015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A015_extra_packed) == 1, "");
_Static_assert(sizeof(struct A015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A015_extra_size) == 4, "");
_Static_assert(_Alignof(struct A015_extra_size) == 1, "");
_Static_assert(sizeof(A016) == 2, "");
_Static_assert(_Alignof(A016) == 2, "");
_Static_assert(sizeof(struct A016_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A016_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A016_extra_packed) == 1, "");
_Static_assert(sizeof(struct A016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A016_extra_size) == 4, "");
_Static_assert(_Alignof(struct A016_extra_size) == 1, "");
_Static_assert(sizeof(A021) == 4, "");
_Static_assert(_Alignof(A021) == 2, "");
_Static_assert(sizeof(struct A021_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A021_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A021_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A021_extra_packed) == 1, "");
_Static_assert(sizeof(struct A021_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A021_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A021_extra_size) == 6, "");
_Static_assert(_Alignof(struct A021_extra_size) == 1, "");
_Static_assert(sizeof(A022) == 4, "");
_Static_assert(_Alignof(A022) == 2, "");
_Static_assert(sizeof(struct A022_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A022_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A022_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A022_extra_packed) == 1, "");
_Static_assert(sizeof(struct A022_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A022_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A022_extra_size) == 6, "");
_Static_assert(_Alignof(struct A022_extra_size) == 1, "");
_Static_assert(sizeof(A023) == 4, "");
_Static_assert(_Alignof(A023) == 2, "");
_Static_assert(sizeof(struct A023_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A023_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A023_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A023_extra_packed) == 1, "");
_Static_assert(sizeof(struct A023_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A023_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A023_extra_size) == 6, "");
_Static_assert(_Alignof(struct A023_extra_size) == 1, "");
_Static_assert(sizeof(A024) == 4, "");
_Static_assert(_Alignof(A024) == 2, "");
_Static_assert(sizeof(struct A024_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A024_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A024_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A024_extra_packed) == 1, "");
_Static_assert(sizeof(struct A024_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A024_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A024_extra_size) == 6, "");
_Static_assert(_Alignof(struct A024_extra_size) == 1, "");
_Static_assert(sizeof(A025) == 4, "");
_Static_assert(_Alignof(A025) == 2, "");
_Static_assert(sizeof(struct A025_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A025_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A025_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A025_extra_packed) == 1, "");
_Static_assert(sizeof(struct A025_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A025_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A025_extra_size) == 6, "");
_Static_assert(_Alignof(struct A025_extra_size) == 1, "");
_Static_assert(sizeof(A026) == 4, "");
_Static_assert(_Alignof(A026) == 2, "");
_Static_assert(sizeof(struct A026_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A026_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A026_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A026_extra_packed) == 1, "");
_Static_assert(sizeof(struct A026_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A026_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A026_extra_size) == 6, "");
_Static_assert(_Alignof(struct A026_extra_size) == 1, "");
_Static_assert(sizeof(A027) == 4, "");
_Static_assert(_Alignof(A027) == 2, "");
_Static_assert(sizeof(struct A027_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A027_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A027_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A027_extra_packed) == 1, "");
_Static_assert(sizeof(struct A027_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A027_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A027_extra_size) == 6, "");
_Static_assert(_Alignof(struct A027_extra_size) == 1, "");
_Static_assert(sizeof(A028) == 4, "");
_Static_assert(_Alignof(A028) == 2, "");
_Static_assert(sizeof(struct A028_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A028_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A028_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A028_extra_packed) == 1, "");
_Static_assert(sizeof(struct A028_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A028_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A028_extra_size) == 6, "");
_Static_assert(_Alignof(struct A028_extra_size) == 1, "");
_Static_assert(sizeof(A029) == 4, "");
_Static_assert(_Alignof(A029) == 2, "");
_Static_assert(sizeof(struct A029_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A029_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A029_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A029_extra_packed) == 1, "");
_Static_assert(sizeof(struct A029_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A029_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A029_extra_size) == 6, "");
_Static_assert(_Alignof(struct A029_extra_size) == 1, "");
_Static_assert(sizeof(A030) == 4, "");
_Static_assert(_Alignof(A030) == 2, "");
_Static_assert(sizeof(struct A030_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A030_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A030_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A030_extra_packed) == 1, "");
_Static_assert(sizeof(struct A030_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A030_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A030_extra_size) == 6, "");
_Static_assert(_Alignof(struct A030_extra_size) == 1, "");
_Static_assert(sizeof(A031) == 4, "");
_Static_assert(_Alignof(A031) == 2, "");
_Static_assert(sizeof(struct A031_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A031_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A031_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A031_extra_packed) == 1, "");
_Static_assert(sizeof(struct A031_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A031_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A031_extra_size) == 6, "");
_Static_assert(_Alignof(struct A031_extra_size) == 1, "");
_Static_assert(sizeof(A032) == 4, "");
_Static_assert(_Alignof(A032) == 2, "");
_Static_assert(sizeof(struct A032_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A032_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A032_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A032_extra_packed) == 1, "");
_Static_assert(sizeof(struct A032_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A032_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A032_extra_size) == 6, "");
_Static_assert(_Alignof(struct A032_extra_size) == 1, "");
_Static_assert(sizeof(A033) == 4, "");
_Static_assert(_Alignof(A033) == 2, "");
_Static_assert(sizeof(struct A033_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A033_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A033_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A033_extra_packed) == 1, "");
_Static_assert(sizeof(struct A033_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A033_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A033_extra_size) == 6, "");
_Static_assert(_Alignof(struct A033_extra_size) == 1, "");
_Static_assert(sizeof(A034) == 4, "");
_Static_assert(_Alignof(A034) == 2, "");
_Static_assert(sizeof(struct A034_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A034_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A034_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A034_extra_packed) == 1, "");
_Static_assert(sizeof(struct A034_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A034_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A034_extra_size) == 6, "");
_Static_assert(_Alignof(struct A034_extra_size) == 1, "");
_Static_assert(sizeof(A035) == 4, "");
_Static_assert(_Alignof(A035) == 2, "");
_Static_assert(sizeof(struct A035_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A035_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A035_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A035_extra_packed) == 1, "");
_Static_assert(sizeof(struct A035_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A035_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A035_extra_size) == 6, "");
_Static_assert(_Alignof(struct A035_extra_size) == 1, "");
_Static_assert(sizeof(A036) == 4, "");
_Static_assert(_Alignof(A036) == 2, "");
_Static_assert(sizeof(struct A036_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A036_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A036_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A036_extra_packed) == 1, "");
_Static_assert(sizeof(struct A036_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A036_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A036_extra_size) == 6, "");
_Static_assert(_Alignof(struct A036_extra_size) == 1, "");
_Static_assert(sizeof(A041) == 8, "");
_Static_assert(_Alignof(A041) == 2, "");
_Static_assert(sizeof(struct A041_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A041_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A041_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A041_extra_packed) == 1, "");
_Static_assert(sizeof(struct A041_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A041_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A041_extra_size) == 10, "");
_Static_assert(_Alignof(struct A041_extra_size) == 1, "");
_Static_assert(sizeof(A042) == 8, "");
_Static_assert(_Alignof(A042) == 2, "");
_Static_assert(sizeof(struct A042_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A042_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A042_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A042_extra_packed) == 1, "");
_Static_assert(sizeof(struct A042_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A042_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A042_extra_size) == 10, "");
_Static_assert(_Alignof(struct A042_extra_size) == 1, "");
_Static_assert(sizeof(A043) == 8, "");
_Static_assert(_Alignof(A043) == 2, "");
_Static_assert(sizeof(struct A043_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A043_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A043_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A043_extra_packed) == 1, "");
_Static_assert(sizeof(struct A043_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A043_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A043_extra_size) == 10, "");
_Static_assert(_Alignof(struct A043_extra_size) == 1, "");
_Static_assert(sizeof(A044) == 8, "");
_Static_assert(_Alignof(A044) == 2, "");
_Static_assert(sizeof(struct A044_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A044_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A044_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A044_extra_packed) == 1, "");
_Static_assert(sizeof(struct A044_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A044_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A044_extra_size) == 10, "");
_Static_assert(_Alignof(struct A044_extra_size) == 1, "");
_Static_assert(sizeof(A045) == 8, "");
_Static_assert(_Alignof(A045) == 2, "");
_Static_assert(sizeof(struct A045_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A045_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A045_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A045_extra_packed) == 1, "");
_Static_assert(sizeof(struct A045_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A045_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A045_extra_size) == 10, "");
_Static_assert(_Alignof(struct A045_extra_size) == 1, "");
_Static_assert(sizeof(A046) == 8, "");
_Static_assert(_Alignof(A046) == 2, "");
_Static_assert(sizeof(struct A046_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A046_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A046_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A046_extra_packed) == 1, "");
_Static_assert(sizeof(struct A046_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A046_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A046_extra_size) == 10, "");
_Static_assert(_Alignof(struct A046_extra_size) == 1, "");
_Static_assert(sizeof(A047) == 8, "");
_Static_assert(_Alignof(A047) == 2, "");
_Static_assert(sizeof(struct A047_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A047_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A047_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A047_extra_packed) == 1, "");
_Static_assert(sizeof(struct A047_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A047_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A047_extra_size) == 10, "");
_Static_assert(_Alignof(struct A047_extra_size) == 1, "");
_Static_assert(sizeof(A048) == 8, "");
_Static_assert(_Alignof(A048) == 2, "");
_Static_assert(sizeof(struct A048_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A048_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A048_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A048_extra_packed) == 1, "");
_Static_assert(sizeof(struct A048_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A048_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A048_extra_size) == 10, "");
_Static_assert(_Alignof(struct A048_extra_size) == 1, "");
_Static_assert(sizeof(A049) == 8, "");
_Static_assert(_Alignof(A049) == 2, "");
_Static_assert(sizeof(struct A049_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A049_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A049_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A049_extra_packed) == 1, "");
_Static_assert(sizeof(struct A049_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A049_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A049_extra_size) == 10, "");
_Static_assert(_Alignof(struct A049_extra_size) == 1, "");
_Static_assert(sizeof(A050) == 8, "");
_Static_assert(_Alignof(A050) == 2, "");
_Static_assert(sizeof(struct A050_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A050_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A050_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A050_extra_packed) == 1, "");
_Static_assert(sizeof(struct A050_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A050_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A050_extra_size) == 10, "");
_Static_assert(_Alignof(struct A050_extra_size) == 1, "");
_Static_assert(sizeof(A051) == 8, "");
_Static_assert(_Alignof(A051) == 2, "");
_Static_assert(sizeof(struct A051_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A051_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A051_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A051_extra_packed) == 1, "");
_Static_assert(sizeof(struct A051_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A051_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A051_extra_size) == 10, "");
_Static_assert(_Alignof(struct A051_extra_size) == 1, "");
_Static_assert(sizeof(A052) == 8, "");
_Static_assert(_Alignof(A052) == 2, "");
_Static_assert(sizeof(struct A052_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A052_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A052_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A052_extra_packed) == 1, "");
_Static_assert(sizeof(struct A052_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A052_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A052_extra_size) == 10, "");
_Static_assert(_Alignof(struct A052_extra_size) == 1, "");
_Static_assert(sizeof(A053) == 8, "");
_Static_assert(_Alignof(A053) == 2, "");
_Static_assert(sizeof(struct A053_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A053_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A053_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A053_extra_packed) == 1, "");
_Static_assert(sizeof(struct A053_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A053_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A053_extra_size) == 10, "");
_Static_assert(_Alignof(struct A053_extra_size) == 1, "");
_Static_assert(sizeof(A054) == 8, "");
_Static_assert(_Alignof(A054) == 2, "");
_Static_assert(sizeof(struct A054_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A054_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A054_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A054_extra_packed) == 1, "");
_Static_assert(sizeof(struct A054_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A054_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A054_extra_size) == 10, "");
_Static_assert(_Alignof(struct A054_extra_size) == 1, "");
_Static_assert(sizeof(A055) == 8, "");
_Static_assert(_Alignof(A055) == 2, "");
_Static_assert(sizeof(struct A055_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A055_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A055_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A055_extra_packed) == 1, "");
_Static_assert(sizeof(struct A055_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A055_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A055_extra_size) == 10, "");
_Static_assert(_Alignof(struct A055_extra_size) == 1, "");
_Static_assert(sizeof(A056) == 8, "");
_Static_assert(_Alignof(A056) == 2, "");
_Static_assert(sizeof(struct A056_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A056_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A056_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A056_extra_packed) == 1, "");
_Static_assert(sizeof(struct A056_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A056_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A056_extra_size) == 10, "");
_Static_assert(_Alignof(struct A056_extra_size) == 1, "");
_Static_assert(sizeof(A061) == 8, "");
_Static_assert(_Alignof(A061) == 2, "");
_Static_assert(sizeof(struct A061_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A061_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A061_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A061_extra_packed) == 1, "");
_Static_assert(sizeof(struct A061_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A061_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A061_extra_size) == 10, "");
_Static_assert(_Alignof(struct A061_extra_size) == 1, "");
_Static_assert(sizeof(A062) == 8, "");
_Static_assert(_Alignof(A062) == 2, "");
_Static_assert(sizeof(struct A062_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A062_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A062_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A062_extra_packed) == 1, "");
_Static_assert(sizeof(struct A062_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A062_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A062_extra_size) == 10, "");
_Static_assert(_Alignof(struct A062_extra_size) == 1, "");
_Static_assert(sizeof(A063) == 8, "");
_Static_assert(_Alignof(A063) == 2, "");
_Static_assert(sizeof(struct A063_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A063_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A063_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A063_extra_packed) == 1, "");
_Static_assert(sizeof(struct A063_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A063_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A063_extra_size) == 10, "");
_Static_assert(_Alignof(struct A063_extra_size) == 1, "");
_Static_assert(sizeof(A064) == 8, "");
_Static_assert(_Alignof(A064) == 2, "");
_Static_assert(sizeof(struct A064_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A064_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A064_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A064_extra_packed) == 1, "");
_Static_assert(sizeof(struct A064_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A064_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A064_extra_size) == 10, "");
_Static_assert(_Alignof(struct A064_extra_size) == 1, "");
_Static_assert(sizeof(A065) == 8, "");
_Static_assert(_Alignof(A065) == 2, "");
_Static_assert(sizeof(struct A065_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A065_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A065_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A065_extra_packed) == 1, "");
_Static_assert(sizeof(struct A065_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A065_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A065_extra_size) == 10, "");
_Static_assert(_Alignof(struct A065_extra_size) == 1, "");
_Static_assert(sizeof(A066) == 8, "");
_Static_assert(_Alignof(A066) == 2, "");
_Static_assert(sizeof(struct A066_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A066_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A066_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A066_extra_packed) == 1, "");
_Static_assert(sizeof(struct A066_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A066_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A066_extra_size) == 10, "");
_Static_assert(_Alignof(struct A066_extra_size) == 1, "");
_Static_assert(sizeof(A067) == 8, "");
_Static_assert(_Alignof(A067) == 2, "");
_Static_assert(sizeof(struct A067_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A067_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A067_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A067_extra_packed) == 1, "");
_Static_assert(sizeof(struct A067_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A067_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A067_extra_size) == 10, "");
_Static_assert(_Alignof(struct A067_extra_size) == 1, "");
_Static_assert(sizeof(A068) == 8, "");
_Static_assert(_Alignof(A068) == 2, "");
_Static_assert(sizeof(struct A068_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A068_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A068_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A068_extra_packed) == 1, "");
_Static_assert(sizeof(struct A068_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A068_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A068_extra_size) == 10, "");
_Static_assert(_Alignof(struct A068_extra_size) == 1, "");
_Static_assert(sizeof(A069) == 8, "");
_Static_assert(_Alignof(A069) == 2, "");
_Static_assert(sizeof(struct A069_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A069_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A069_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A069_extra_packed) == 1, "");
_Static_assert(sizeof(struct A069_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A069_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A069_extra_size) == 10, "");
_Static_assert(_Alignof(struct A069_extra_size) == 1, "");
_Static_assert(sizeof(A070) == 8, "");
_Static_assert(_Alignof(A070) == 2, "");
_Static_assert(sizeof(struct A070_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A070_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A070_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A070_extra_packed) == 1, "");
_Static_assert(sizeof(struct A070_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A070_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A070_extra_size) == 10, "");
_Static_assert(_Alignof(struct A070_extra_size) == 1, "");
_Static_assert(sizeof(A071) == 8, "");
_Static_assert(_Alignof(A071) == 2, "");
_Static_assert(sizeof(struct A071_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A071_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A071_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A071_extra_packed) == 1, "");
_Static_assert(sizeof(struct A071_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A071_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A071_extra_size) == 10, "");
_Static_assert(_Alignof(struct A071_extra_size) == 1, "");
_Static_assert(sizeof(A072) == 8, "");
_Static_assert(_Alignof(A072) == 2, "");
_Static_assert(sizeof(struct A072_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A072_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A072_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A072_extra_packed) == 1, "");
_Static_assert(sizeof(struct A072_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A072_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A072_extra_size) == 10, "");
_Static_assert(_Alignof(struct A072_extra_size) == 1, "");
_Static_assert(sizeof(A073) == 8, "");
_Static_assert(_Alignof(A073) == 2, "");
_Static_assert(sizeof(struct A073_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A073_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A073_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A073_extra_packed) == 1, "");
_Static_assert(sizeof(struct A073_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A073_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A073_extra_size) == 10, "");
_Static_assert(_Alignof(struct A073_extra_size) == 1, "");
_Static_assert(sizeof(A074) == 8, "");
_Static_assert(_Alignof(A074) == 2, "");
_Static_assert(sizeof(struct A074_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A074_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A074_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A074_extra_packed) == 1, "");
_Static_assert(sizeof(struct A074_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A074_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A074_extra_size) == 10, "");
_Static_assert(_Alignof(struct A074_extra_size) == 1, "");
_Static_assert(sizeof(A075) == 8, "");
_Static_assert(_Alignof(A075) == 2, "");
_Static_assert(sizeof(struct A075_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A075_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A075_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A075_extra_packed) == 1, "");
_Static_assert(sizeof(struct A075_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A075_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A075_extra_size) == 10, "");
_Static_assert(_Alignof(struct A075_extra_size) == 1, "");
_Static_assert(sizeof(A076) == 8, "");
_Static_assert(_Alignof(A076) == 2, "");
_Static_assert(sizeof(struct A076_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A076_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A076_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A076_extra_packed) == 1, "");
_Static_assert(sizeof(struct A076_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A076_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A076_extra_size) == 10, "");
_Static_assert(_Alignof(struct A076_extra_size) == 1, "");
_Static_assert(sizeof(A081) == 1, "");
_Static_assert(_Alignof(A081) == 1, "");
_Static_assert(sizeof(struct A081_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A081_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A081_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A081_extra_packed) == 1, "");
_Static_assert(sizeof(struct A081_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A081_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A081_extra_size) == 3, "");
_Static_assert(_Alignof(struct A081_extra_size) == 1, "");
_Static_assert(sizeof(A082) == 1, "");
_Static_assert(_Alignof(A082) == 1, "");
_Static_assert(sizeof(struct A082_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A082_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A082_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A082_extra_packed) == 1, "");
_Static_assert(sizeof(struct A082_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A082_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A082_extra_size) == 3, "");
_Static_assert(_Alignof(struct A082_extra_size) == 1, "");
_Static_assert(sizeof(A083) == 1, "");
_Static_assert(_Alignof(A083) == 1, "");
_Static_assert(sizeof(struct A083_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A083_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A083_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A083_extra_packed) == 1, "");
_Static_assert(sizeof(struct A083_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A083_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A083_extra_size) == 3, "");
_Static_assert(_Alignof(struct A083_extra_size) == 1, "");
_Static_assert(sizeof(A084) == 1, "");
_Static_assert(_Alignof(A084) == 1, "");
_Static_assert(sizeof(struct A084_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A084_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A084_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A084_extra_packed) == 1, "");
_Static_assert(sizeof(struct A084_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A084_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A084_extra_size) == 3, "");
_Static_assert(_Alignof(struct A084_extra_size) == 1, "");
_Static_assert(sizeof(A085) == 1, "");
_Static_assert(_Alignof(A085) == 1, "");
_Static_assert(sizeof(struct A085_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A085_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A085_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A085_extra_packed) == 1, "");
_Static_assert(sizeof(struct A085_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A085_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A085_extra_size) == 3, "");
_Static_assert(_Alignof(struct A085_extra_size) == 1, "");
_Static_assert(sizeof(A086) == 1, "");
_Static_assert(_Alignof(A086) == 1, "");
_Static_assert(sizeof(struct A086_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A086_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A086_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A086_extra_packed) == 1, "");
_Static_assert(sizeof(struct A086_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A086_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A086_extra_size) == 3, "");
_Static_assert(_Alignof(struct A086_extra_size) == 1, "");
_Static_assert(sizeof(A087) == 1, "");
_Static_assert(_Alignof(A087) == 1, "");
_Static_assert(sizeof(struct A087_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A087_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A087_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A087_extra_packed) == 1, "");
_Static_assert(sizeof(struct A087_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A087_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A087_extra_size) == 3, "");
_Static_assert(_Alignof(struct A087_extra_size) == 1, "");
_Static_assert(sizeof(A088) == 1, "");
_Static_assert(_Alignof(A088) == 1, "");
_Static_assert(sizeof(struct A088_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A088_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A088_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A088_extra_packed) == 1, "");
_Static_assert(sizeof(struct A088_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A088_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A088_extra_size) == 3, "");
_Static_assert(_Alignof(struct A088_extra_size) == 1, "");
_Static_assert(sizeof(A089) == 2, "");
_Static_assert(_Alignof(A089) == 2, "");
_Static_assert(sizeof(struct A089_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A089_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A089_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A089_extra_packed) == 1, "");
_Static_assert(sizeof(struct A089_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A089_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A089_extra_size) == 4, "");
_Static_assert(_Alignof(struct A089_extra_size) == 1, "");
_Static_assert(sizeof(A090) == 2, "");
_Static_assert(_Alignof(A090) == 2, "");
_Static_assert(sizeof(struct A090_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A090_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A090_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A090_extra_packed) == 1, "");
_Static_assert(sizeof(struct A090_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A090_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A090_extra_size) == 4, "");
_Static_assert(_Alignof(struct A090_extra_size) == 1, "");
_Static_assert(sizeof(A091) == 2, "");
_Static_assert(_Alignof(A091) == 2, "");
_Static_assert(sizeof(struct A091_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A091_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A091_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A091_extra_packed) == 1, "");
_Static_assert(sizeof(struct A091_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A091_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A091_extra_size) == 4, "");
_Static_assert(_Alignof(struct A091_extra_size) == 1, "");
_Static_assert(sizeof(A092) == 2, "");
_Static_assert(_Alignof(A092) == 2, "");
_Static_assert(sizeof(struct A092_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A092_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A092_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A092_extra_packed) == 1, "");
_Static_assert(sizeof(struct A092_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A092_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A092_extra_size) == 4, "");
_Static_assert(_Alignof(struct A092_extra_size) == 1, "");
_Static_assert(sizeof(A093) == 2, "");
_Static_assert(_Alignof(A093) == 2, "");
_Static_assert(sizeof(struct A093_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A093_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A093_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A093_extra_packed) == 1, "");
_Static_assert(sizeof(struct A093_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A093_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A093_extra_size) == 4, "");
_Static_assert(_Alignof(struct A093_extra_size) == 1, "");
_Static_assert(sizeof(A094) == 2, "");
_Static_assert(_Alignof(A094) == 2, "");
_Static_assert(sizeof(struct A094_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A094_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A094_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A094_extra_packed) == 1, "");
_Static_assert(sizeof(struct A094_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A094_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A094_extra_size) == 4, "");
_Static_assert(_Alignof(struct A094_extra_size) == 1, "");
_Static_assert(sizeof(A095) == 2, "");
_Static_assert(_Alignof(A095) == 2, "");
_Static_assert(sizeof(struct A095_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A095_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A095_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A095_extra_packed) == 1, "");
_Static_assert(sizeof(struct A095_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A095_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A095_extra_size) == 4, "");
_Static_assert(_Alignof(struct A095_extra_size) == 1, "");
_Static_assert(sizeof(A096) == 2, "");
_Static_assert(_Alignof(A096) == 2, "");
_Static_assert(sizeof(struct A096_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A096_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A096_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A096_extra_packed) == 1, "");
_Static_assert(sizeof(struct A096_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A096_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A096_extra_size) == 4, "");
_Static_assert(_Alignof(struct A096_extra_size) == 1, "");
_Static_assert(sizeof(A101) == 4, "");
_Static_assert(_Alignof(A101) == 2, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 6, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
_Static_assert(sizeof(A102) == 4, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 6, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
_Static_assert(sizeof(A103) == 4, "");
_Static_assert(_Alignof(A103) == 2, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 6, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
_Static_assert(sizeof(A104) == 4, "");
_Static_assert(_Alignof(A104) == 2, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 6, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
_Static_assert(sizeof(A106) == 4, "");
_Static_assert(_Alignof(A106) == 2, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 6, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
_Static_assert(sizeof(A107) == 4, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 6, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
_Static_assert(sizeof(A108) == 4, "");
_Static_assert(_Alignof(A108) == 2, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 6, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
_Static_assert(sizeof(A109) == 4, "");
_Static_assert(_Alignof(A109) == 2, "");
_Static_assert(sizeof(struct A109_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A109_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A109_extra_packed) == 1, "");
_Static_assert(sizeof(struct A109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A109_extra_size) == 6, "");
_Static_assert(_Alignof(struct A109_extra_size) == 1, "");
_Static_assert(sizeof(A110) == 4, "");
_Static_assert(_Alignof(A110) == 2, "");
_Static_assert(sizeof(struct A110_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A110_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A110_extra_packed) == 1, "");
_Static_assert(sizeof(struct A110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A110_extra_size) == 6, "");
_Static_assert(_Alignof(struct A110_extra_size) == 1, "");
_Static_assert(sizeof(A111) == 4, "");
_Static_assert(_Alignof(A111) == 2, "");
_Static_assert(sizeof(struct A111_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A111_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A111_extra_packed) == 1, "");
_Static_assert(sizeof(struct A111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A111_extra_size) == 6, "");
_Static_assert(_Alignof(struct A111_extra_size) == 1, "");
_Static_assert(sizeof(A112) == 4, "");
_Static_assert(_Alignof(A112) == 2, "");
_Static_assert(sizeof(struct A112_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A112_extra_packed) == 1, "");
_Static_assert(sizeof(struct A112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A112_extra_size) == 6, "");
_Static_assert(_Alignof(struct A112_extra_size) == 1, "");
_Static_assert(sizeof(A113) == 4, "");
_Static_assert(_Alignof(A113) == 2, "");
_Static_assert(sizeof(struct A113_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A113_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A113_extra_packed) == 1, "");
_Static_assert(sizeof(struct A113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A113_extra_size) == 6, "");
_Static_assert(_Alignof(struct A113_extra_size) == 1, "");
_Static_assert(sizeof(A114) == 4, "");
_Static_assert(_Alignof(A114) == 2, "");
_Static_assert(sizeof(struct A114_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A114_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A114_extra_packed) == 1, "");
_Static_assert(sizeof(struct A114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A114_extra_size) == 6, "");
_Static_assert(_Alignof(struct A114_extra_size) == 1, "");
_Static_assert(sizeof(A115) == 4, "");
_Static_assert(_Alignof(A115) == 2, "");
_Static_assert(sizeof(struct A115_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A115_extra_packed) == 1, "");
_Static_assert(sizeof(struct A115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A115_extra_size) == 6, "");
_Static_assert(_Alignof(struct A115_extra_size) == 1, "");
_Static_assert(sizeof(A116) == 4, "");
_Static_assert(_Alignof(A116) == 2, "");
_Static_assert(sizeof(struct A116_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A116_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A116_extra_packed) == 1, "");
_Static_assert(sizeof(struct A116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A116_extra_size) == 6, "");
_Static_assert(_Alignof(struct A116_extra_size) == 1, "");
_Static_assert(sizeof(A121) == 8, "");
_Static_assert(_Alignof(A121) == 2, "");
_Static_assert(sizeof(struct A121_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A121_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A121_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A121_extra_packed) == 1, "");
_Static_assert(sizeof(struct A121_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A121_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A121_extra_size) == 10, "");
_Static_assert(_Alignof(struct A121_extra_size) == 1, "");
_Static_assert(sizeof(A122) == 8, "");
_Static_assert(_Alignof(A122) == 2, "");
_Static_assert(sizeof(struct A122_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A122_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A122_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A122_extra_packed) == 1, "");
_Static_assert(sizeof(struct A122_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A122_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A122_extra_size) == 10, "");
_Static_assert(_Alignof(struct A122_extra_size) == 1, "");
_Static_assert(sizeof(A123) == 8, "");
_Static_assert(_Alignof(A123) == 2, "");
_Static_assert(sizeof(struct A123_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A123_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A123_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A123_extra_packed) == 1, "");
_Static_assert(sizeof(struct A123_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A123_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A123_extra_size) == 10, "");
_Static_assert(_Alignof(struct A123_extra_size) == 1, "");
_Static_assert(sizeof(A124) == 8, "");
_Static_assert(_Alignof(A124) == 2, "");
_Static_assert(sizeof(struct A124_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A124_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A124_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A124_extra_packed) == 1, "");
_Static_assert(sizeof(struct A124_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A124_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A124_extra_size) == 10, "");
_Static_assert(_Alignof(struct A124_extra_size) == 1, "");
_Static_assert(sizeof(A125) == 8, "");
_Static_assert(_Alignof(A125) == 2, "");
_Static_assert(sizeof(struct A125_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A125_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A125_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A125_extra_packed) == 1, "");
_Static_assert(sizeof(struct A125_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A125_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A125_extra_size) == 10, "");
_Static_assert(_Alignof(struct A125_extra_size) == 1, "");
_Static_assert(sizeof(A126) == 8, "");
_Static_assert(_Alignof(A126) == 2, "");
_Static_assert(sizeof(struct A126_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A126_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A126_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A126_extra_packed) == 1, "");
_Static_assert(sizeof(struct A126_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A126_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A126_extra_size) == 10, "");
_Static_assert(_Alignof(struct A126_extra_size) == 1, "");
_Static_assert(sizeof(A127) == 8, "");
_Static_assert(_Alignof(A127) == 2, "");
_Static_assert(sizeof(struct A127_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A127_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A127_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A127_extra_packed) == 1, "");
_Static_assert(sizeof(struct A127_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A127_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A127_extra_size) == 10, "");
_Static_assert(_Alignof(struct A127_extra_size) == 1, "");
_Static_assert(sizeof(A128) == 8, "");
_Static_assert(_Alignof(A128) == 2, "");
_Static_assert(sizeof(struct A128_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A128_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A128_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A128_extra_packed) == 1, "");
_Static_assert(sizeof(struct A128_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A128_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A128_extra_size) == 10, "");
_Static_assert(_Alignof(struct A128_extra_size) == 1, "");
_Static_assert(sizeof(A129) == 8, "");
_Static_assert(_Alignof(A129) == 2, "");
_Static_assert(sizeof(struct A129_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A129_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A129_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A129_extra_packed) == 1, "");
_Static_assert(sizeof(struct A129_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A129_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A129_extra_size) == 10, "");
_Static_assert(_Alignof(struct A129_extra_size) == 1, "");
_Static_assert(sizeof(A130) == 8, "");
_Static_assert(_Alignof(A130) == 2, "");
_Static_assert(sizeof(struct A130_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A130_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A130_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A130_extra_packed) == 1, "");
_Static_assert(sizeof(struct A130_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A130_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A130_extra_size) == 10, "");
_Static_assert(_Alignof(struct A130_extra_size) == 1, "");
_Static_assert(sizeof(A131) == 8, "");
_Static_assert(_Alignof(A131) == 2, "");
_Static_assert(sizeof(struct A131_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A131_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A131_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A131_extra_packed) == 1, "");
_Static_assert(sizeof(struct A131_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A131_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A131_extra_size) == 10, "");
_Static_assert(_Alignof(struct A131_extra_size) == 1, "");
_Static_assert(sizeof(A132) == 8, "");
_Static_assert(_Alignof(A132) == 2, "");
_Static_assert(sizeof(struct A132_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A132_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A132_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A132_extra_packed) == 1, "");
_Static_assert(sizeof(struct A132_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A132_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A132_extra_size) == 10, "");
_Static_assert(_Alignof(struct A132_extra_size) == 1, "");
_Static_assert(sizeof(A133) == 8, "");
_Static_assert(_Alignof(A133) == 2, "");
_Static_assert(sizeof(struct A133_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A133_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A133_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A133_extra_packed) == 1, "");
_Static_assert(sizeof(struct A133_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A133_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A133_extra_size) == 10, "");
_Static_assert(_Alignof(struct A133_extra_size) == 1, "");
_Static_assert(sizeof(A134) == 8, "");
_Static_assert(_Alignof(A134) == 2, "");
_Static_assert(sizeof(struct A134_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A134_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A134_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A134_extra_packed) == 1, "");
_Static_assert(sizeof(struct A134_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A134_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A134_extra_size) == 10, "");
_Static_assert(_Alignof(struct A134_extra_size) == 1, "");
_Static_assert(sizeof(A135) == 8, "");
_Static_assert(_Alignof(A135) == 2, "");
_Static_assert(sizeof(struct A135_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A135_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A135_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A135_extra_packed) == 1, "");
_Static_assert(sizeof(struct A135_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A135_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A135_extra_size) == 10, "");
_Static_assert(_Alignof(struct A135_extra_size) == 1, "");
_Static_assert(sizeof(A136) == 8, "");
_Static_assert(_Alignof(A136) == 2, "");
_Static_assert(sizeof(struct A136_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A136_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A136_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A136_extra_packed) == 1, "");
_Static_assert(sizeof(struct A136_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A136_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A136_extra_size) == 10, "");
_Static_assert(_Alignof(struct A136_extra_size) == 1, "");
_Static_assert(sizeof(A141) == 8, "");
_Static_assert(_Alignof(A141) == 2, "");
_Static_assert(sizeof(struct A141_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A141_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A141_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A141_extra_packed) == 1, "");
_Static_assert(sizeof(struct A141_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A141_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A141_extra_size) == 10, "");
_Static_assert(_Alignof(struct A141_extra_size) == 1, "");
_Static_assert(sizeof(A142) == 8, "");
_Static_assert(_Alignof(A142) == 2, "");
_Static_assert(sizeof(struct A142_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A142_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A142_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A142_extra_packed) == 1, "");
_Static_assert(sizeof(struct A142_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A142_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A142_extra_size) == 10, "");
_Static_assert(_Alignof(struct A142_extra_size) == 1, "");
_Static_assert(sizeof(A143) == 8, "");
_Static_assert(_Alignof(A143) == 2, "");
_Static_assert(sizeof(struct A143_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A143_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A143_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A143_extra_packed) == 1, "");
_Static_assert(sizeof(struct A143_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A143_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A143_extra_size) == 10, "");
_Static_assert(_Alignof(struct A143_extra_size) == 1, "");
_Static_assert(sizeof(A144) == 8, "");
_Static_assert(_Alignof(A144) == 2, "");
_Static_assert(sizeof(struct A144_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A144_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A144_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A144_extra_packed) == 1, "");
_Static_assert(sizeof(struct A144_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A144_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A144_extra_size) == 10, "");
_Static_assert(_Alignof(struct A144_extra_size) == 1, "");
_Static_assert(sizeof(A145) == 8, "");
_Static_assert(_Alignof(A145) == 2, "");
_Static_assert(sizeof(struct A145_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A145_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A145_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A145_extra_packed) == 1, "");
_Static_assert(sizeof(struct A145_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A145_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A145_extra_size) == 10, "");
_Static_assert(_Alignof(struct A145_extra_size) == 1, "");
_Static_assert(sizeof(A146) == 8, "");
_Static_assert(_Alignof(A146) == 2, "");
_Static_assert(sizeof(struct A146_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A146_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A146_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A146_extra_packed) == 1, "");
_Static_assert(sizeof(struct A146_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A146_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A146_extra_size) == 10, "");
_Static_assert(_Alignof(struct A146_extra_size) == 1, "");
_Static_assert(sizeof(A147) == 8, "");
_Static_assert(_Alignof(A147) == 2, "");
_Static_assert(sizeof(struct A147_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A147_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A147_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A147_extra_packed) == 1, "");
_Static_assert(sizeof(struct A147_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A147_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A147_extra_size) == 10, "");
_Static_assert(_Alignof(struct A147_extra_size) == 1, "");
_Static_assert(sizeof(A148) == 8, "");
_Static_assert(_Alignof(A148) == 2, "");
_Static_assert(sizeof(struct A148_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A148_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A148_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A148_extra_packed) == 1, "");
_Static_assert(sizeof(struct A148_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A148_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A148_extra_size) == 10, "");
_Static_assert(_Alignof(struct A148_extra_size) == 1, "");
_Static_assert(sizeof(A149) == 8, "");
_Static_assert(_Alignof(A149) == 2, "");
_Static_assert(sizeof(struct A149_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A149_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A149_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A149_extra_packed) == 1, "");
_Static_assert(sizeof(struct A149_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A149_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A149_extra_size) == 10, "");
_Static_assert(_Alignof(struct A149_extra_size) == 1, "");
_Static_assert(sizeof(A150) == 8, "");
_Static_assert(_Alignof(A150) == 2, "");
_Static_assert(sizeof(struct A150_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A150_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A150_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A150_extra_packed) == 1, "");
_Static_assert(sizeof(struct A150_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A150_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A150_extra_size) == 10, "");
_Static_assert(_Alignof(struct A150_extra_size) == 1, "");
_Static_assert(sizeof(A151) == 8, "");
_Static_assert(_Alignof(A151) == 2, "");
_Static_assert(sizeof(struct A151_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A151_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A151_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A151_extra_packed) == 1, "");
_Static_assert(sizeof(struct A151_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A151_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A151_extra_size) == 10, "");
_Static_assert(_Alignof(struct A151_extra_size) == 1, "");
_Static_assert(sizeof(A152) == 8, "");
_Static_assert(_Alignof(A152) == 2, "");
_Static_assert(sizeof(struct A152_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A152_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A152_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A152_extra_packed) == 1, "");
_Static_assert(sizeof(struct A152_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A152_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A152_extra_size) == 10, "");
_Static_assert(_Alignof(struct A152_extra_size) == 1, "");
_Static_assert(sizeof(A153) == 8, "");
_Static_assert(_Alignof(A153) == 2, "");
_Static_assert(sizeof(struct A153_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A153_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A153_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A153_extra_packed) == 1, "");
_Static_assert(sizeof(struct A153_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A153_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A153_extra_size) == 10, "");
_Static_assert(_Alignof(struct A153_extra_size) == 1, "");
_Static_assert(sizeof(A154) == 8, "");
_Static_assert(_Alignof(A154) == 2, "");
_Static_assert(sizeof(struct A154_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A154_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A154_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A154_extra_packed) == 1, "");
_Static_assert(sizeof(struct A154_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A154_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A154_extra_size) == 10, "");
_Static_assert(_Alignof(struct A154_extra_size) == 1, "");
_Static_assert(sizeof(A155) == 8, "");
_Static_assert(_Alignof(A155) == 2, "");
_Static_assert(sizeof(struct A155_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A155_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A155_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A155_extra_packed) == 1, "");
_Static_assert(sizeof(struct A155_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A155_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A155_extra_size) == 10, "");
_Static_assert(_Alignof(struct A155_extra_size) == 1, "");
_Static_assert(sizeof(A156) == 8, "");
_Static_assert(_Alignof(A156) == 2, "");
_Static_assert(sizeof(struct A156_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A156_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A156_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A156_extra_packed) == 1, "");
_Static_assert(sizeof(struct A156_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A156_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A156_extra_size) == 10, "");
_Static_assert(_Alignof(struct A156_extra_size) == 1, "");
_Static_assert(sizeof(B000) == 2, "");
_Static_assert(_Alignof(B000) == 2, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B000_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 4, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
_Static_assert(sizeof(B001) == 2, "");
_Static_assert(_Alignof(B001) == 2, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B001_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 4, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
_Static_assert(sizeof(B002) == 2, "");
_Static_assert(_Alignof(B002) == 2, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B002_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 4, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
_Static_assert(sizeof(B003) == 2, "");
_Static_assert(_Alignof(B003) == 2, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B003_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 4, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
_Static_assert(sizeof(B004) == 2, "");
_Static_assert(_Alignof(B004) == 2, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B004_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 4, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 2, "");
_Static_assert(_Alignof(B005) == 2, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B005_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 4, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
_Static_assert(sizeof(B006) == 2, "");
_Static_assert(_Alignof(B006) == 2, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B006_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 4, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
_Static_assert(sizeof(B007) == 2, "");
_Static_assert(_Alignof(B007) == 2, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B007_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 4, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
_Static_assert(sizeof(B008) == 2, "");
_Static_assert(_Alignof(B008) == 2, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B008_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 4, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
_Static_assert(sizeof(B009) == 2, "");
_Static_assert(_Alignof(B009) == 2, "");
_Static_assert(sizeof(struct B009_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B009_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B009_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B009_extra_packed) == 1, "");
_Static_assert(sizeof(struct B009_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B009_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B009_extra_size) == 4, "");
_Static_assert(_Alignof(struct B009_extra_size) == 1, "");
_Static_assert(sizeof(B010) == 2, "");
_Static_assert(_Alignof(B010) == 2, "");
_Static_assert(sizeof(struct B010_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B010_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B010_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B010_extra_packed) == 1, "");
_Static_assert(sizeof(struct B010_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B010_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B010_extra_size) == 4, "");
_Static_assert(_Alignof(struct B010_extra_size) == 1, "");
_Static_assert(sizeof(B011) == 2, "");
_Static_assert(_Alignof(B011) == 2, "");
_Static_assert(sizeof(struct B011_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B011_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B011_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B011_extra_packed) == 1, "");
_Static_assert(sizeof(struct B011_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B011_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B011_extra_size) == 4, "");
_Static_assert(_Alignof(struct B011_extra_size) == 1, "");
_Static_assert(sizeof(B012) == 2, "");
_Static_assert(_Alignof(B012) == 2, "");
_Static_assert(sizeof(struct B012_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B012_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B012_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B012_extra_packed) == 1, "");
_Static_assert(sizeof(struct B012_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B012_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B012_extra_size) == 4, "");
_Static_assert(_Alignof(struct B012_extra_size) == 1, "");
_Static_assert(sizeof(B013) == 2, "");
_Static_assert(_Alignof(B013) == 2, "");
_Static_assert(sizeof(struct B013_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B013_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B013_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B013_extra_packed) == 1, "");
_Static_assert(sizeof(struct B013_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B013_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B013_extra_size) == 4, "");
_Static_assert(_Alignof(struct B013_extra_size) == 1, "");
_Static_assert(sizeof(B014) == 2, "");
_Static_assert(_Alignof(B014) == 2, "");
_Static_assert(sizeof(struct B014_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B014_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B014_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B014_extra_packed) == 1, "");
_Static_assert(sizeof(struct B014_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B014_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B014_extra_size) == 4, "");
_Static_assert(_Alignof(struct B014_extra_size) == 1, "");
_Static_assert(sizeof(B015) == 2, "");
_Static_assert(_Alignof(B015) == 2, "");
_Static_assert(sizeof(struct B015_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B015_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B015_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B015_extra_packed) == 1, "");
_Static_assert(sizeof(struct B015_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B015_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B015_extra_size) == 4, "");
_Static_assert(_Alignof(struct B015_extra_size) == 1, "");
_Static_assert(sizeof(B016) == 2, "");
_Static_assert(_Alignof(B016) == 2, "");
_Static_assert(sizeof(struct B016_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B016_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B016_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B016_extra_packed) == 1, "");
_Static_assert(sizeof(struct B016_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B016_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B016_extra_size) == 4, "");
_Static_assert(_Alignof(struct B016_extra_size) == 1, "");
_Static_assert(sizeof(B021) == 4, "");
_Static_assert(_Alignof(B021) == 2, "");
_Static_assert(sizeof(struct B021_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B021_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B021_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B021_extra_packed) == 1, "");
_Static_assert(sizeof(struct B021_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B021_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B021_extra_size) == 6, "");
_Static_assert(_Alignof(struct B021_extra_size) == 1, "");
_Static_assert(sizeof(B022) == 4, "");
_Static_assert(_Alignof(B022) == 2, "");
_Static_assert(sizeof(struct B022_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B022_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B022_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B022_extra_packed) == 1, "");
_Static_assert(sizeof(struct B022_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B022_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B022_extra_size) == 6, "");
_Static_assert(_Alignof(struct B022_extra_size) == 1, "");
_Static_assert(sizeof(B023) == 4, "");
_Static_assert(_Alignof(B023) == 2, "");
_Static_assert(sizeof(struct B023_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B023_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B023_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B023_extra_packed) == 1, "");
_Static_assert(sizeof(struct B023_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B023_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B023_extra_size) == 6, "");
_Static_assert(_Alignof(struct B023_extra_size) == 1, "");
_Static_assert(sizeof(B024) == 4, "");
_Static_assert(_Alignof(B024) == 2, "");
_Static_assert(sizeof(struct B024_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B024_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B024_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B024_extra_packed) == 1, "");
_Static_assert(sizeof(struct B024_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B024_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B024_extra_size) == 6, "");
_Static_assert(_Alignof(struct B024_extra_size) == 1, "");
_Static_assert(sizeof(B025) == 4, "");
_Static_assert(_Alignof(B025) == 2, "");
_Static_assert(sizeof(struct B025_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B025_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B025_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B025_extra_packed) == 1, "");
_Static_assert(sizeof(struct B025_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B025_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B025_extra_size) == 6, "");
_Static_assert(_Alignof(struct B025_extra_size) == 1, "");
_Static_assert(sizeof(B026) == 4, "");
_Static_assert(_Alignof(B026) == 2, "");
_Static_assert(sizeof(struct B026_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B026_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B026_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B026_extra_packed) == 1, "");
_Static_assert(sizeof(struct B026_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B026_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B026_extra_size) == 6, "");
_Static_assert(_Alignof(struct B026_extra_size) == 1, "");
_Static_assert(sizeof(B027) == 4, "");
_Static_assert(_Alignof(B027) == 2, "");
_Static_assert(sizeof(struct B027_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B027_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B027_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B027_extra_packed) == 1, "");
_Static_assert(sizeof(struct B027_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B027_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B027_extra_size) == 6, "");
_Static_assert(_Alignof(struct B027_extra_size) == 1, "");
_Static_assert(sizeof(B028) == 4, "");
_Static_assert(_Alignof(B028) == 2, "");
_Static_assert(sizeof(struct B028_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B028_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B028_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B028_extra_packed) == 1, "");
_Static_assert(sizeof(struct B028_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B028_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B028_extra_size) == 6, "");
_Static_assert(_Alignof(struct B028_extra_size) == 1, "");
_Static_assert(sizeof(B029) == 4, "");
_Static_assert(_Alignof(B029) == 2, "");
_Static_assert(sizeof(struct B029_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B029_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B029_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B029_extra_packed) == 1, "");
_Static_assert(sizeof(struct B029_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B029_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B029_extra_size) == 6, "");
_Static_assert(_Alignof(struct B029_extra_size) == 1, "");
_Static_assert(sizeof(B030) == 4, "");
_Static_assert(_Alignof(B030) == 2, "");
_Static_assert(sizeof(struct B030_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B030_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B030_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B030_extra_packed) == 1, "");
_Static_assert(sizeof(struct B030_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B030_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B030_extra_size) == 6, "");
_Static_assert(_Alignof(struct B030_extra_size) == 1, "");
_Static_assert(sizeof(B031) == 4, "");
_Static_assert(_Alignof(B031) == 2, "");
_Static_assert(sizeof(struct B031_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B031_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B031_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B031_extra_packed) == 1, "");
_Static_assert(sizeof(struct B031_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B031_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B031_extra_size) == 6, "");
_Static_assert(_Alignof(struct B031_extra_size) == 1, "");
_Static_assert(sizeof(B032) == 4, "");
_Static_assert(_Alignof(B032) == 2, "");
_Static_assert(sizeof(struct B032_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B032_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B032_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B032_extra_packed) == 1, "");
_Static_assert(sizeof(struct B032_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B032_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B032_extra_size) == 6, "");
_Static_assert(_Alignof(struct B032_extra_size) == 1, "");
_Static_assert(sizeof(B033) == 4, "");
_Static_assert(_Alignof(B033) == 2, "");
_Static_assert(sizeof(struct B033_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B033_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B033_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B033_extra_packed) == 1, "");
_Static_assert(sizeof(struct B033_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B033_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B033_extra_size) == 6, "");
_Static_assert(_Alignof(struct B033_extra_size) == 1, "");
_Static_assert(sizeof(B034) == 4, "");
_Static_assert(_Alignof(B034) == 2, "");
_Static_assert(sizeof(struct B034_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B034_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B034_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B034_extra_packed) == 1, "");
_Static_assert(sizeof(struct B034_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B034_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B034_extra_size) == 6, "");
_Static_assert(_Alignof(struct B034_extra_size) == 1, "");
_Static_assert(sizeof(B035) == 4, "");
_Static_assert(_Alignof(B035) == 2, "");
_Static_assert(sizeof(struct B035_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B035_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B035_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B035_extra_packed) == 1, "");
_Static_assert(sizeof(struct B035_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B035_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B035_extra_size) == 6, "");
_Static_assert(_Alignof(struct B035_extra_size) == 1, "");
_Static_assert(sizeof(B036) == 4, "");
_Static_assert(_Alignof(B036) == 2, "");
_Static_assert(sizeof(struct B036_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B036_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B036_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B036_extra_packed) == 1, "");
_Static_assert(sizeof(struct B036_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B036_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B036_extra_size) == 6, "");
_Static_assert(_Alignof(struct B036_extra_size) == 1, "");
_Static_assert(sizeof(B041) == 8, "");
_Static_assert(_Alignof(B041) == 2, "");
_Static_assert(sizeof(struct B041_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B041_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B041_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B041_extra_packed) == 1, "");
_Static_assert(sizeof(struct B041_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B041_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B041_extra_size) == 10, "");
_Static_assert(_Alignof(struct B041_extra_size) == 1, "");
_Static_assert(sizeof(B042) == 8, "");
_Static_assert(_Alignof(B042) == 2, "");
_Static_assert(sizeof(struct B042_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B042_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B042_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B042_extra_packed) == 1, "");
_Static_assert(sizeof(struct B042_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B042_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B042_extra_size) == 10, "");
_Static_assert(_Alignof(struct B042_extra_size) == 1, "");
_Static_assert(sizeof(B043) == 8, "");
_Static_assert(_Alignof(B043) == 2, "");
_Static_assert(sizeof(struct B043_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B043_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B043_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B043_extra_packed) == 1, "");
_Static_assert(sizeof(struct B043_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B043_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B043_extra_size) == 10, "");
_Static_assert(_Alignof(struct B043_extra_size) == 1, "");
_Static_assert(sizeof(B044) == 8, "");
_Static_assert(_Alignof(B044) == 2, "");
_Static_assert(sizeof(struct B044_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B044_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B044_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B044_extra_packed) == 1, "");
_Static_assert(sizeof(struct B044_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B044_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B044_extra_size) == 10, "");
_Static_assert(_Alignof(struct B044_extra_size) == 1, "");
_Static_assert(sizeof(B045) == 8, "");
_Static_assert(_Alignof(B045) == 2, "");
_Static_assert(sizeof(struct B045_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B045_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B045_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B045_extra_packed) == 1, "");
_Static_assert(sizeof(struct B045_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B045_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B045_extra_size) == 10, "");
_Static_assert(_Alignof(struct B045_extra_size) == 1, "");
_Static_assert(sizeof(B046) == 8, "");
_Static_assert(_Alignof(B046) == 2, "");
_Static_assert(sizeof(struct B046_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B046_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B046_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B046_extra_packed) == 1, "");
_Static_assert(sizeof(struct B046_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B046_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B046_extra_size) == 10, "");
_Static_assert(_Alignof(struct B046_extra_size) == 1, "");
_Static_assert(sizeof(B047) == 8, "");
_Static_assert(_Alignof(B047) == 2, "");
_Static_assert(sizeof(struct B047_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B047_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B047_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B047_extra_packed) == 1, "");
_Static_assert(sizeof(struct B047_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B047_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B047_extra_size) == 10, "");
_Static_assert(_Alignof(struct B047_extra_size) == 1, "");
_Static_assert(sizeof(B048) == 8, "");
_Static_assert(_Alignof(B048) == 2, "");
_Static_assert(sizeof(struct B048_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B048_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B048_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B048_extra_packed) == 1, "");
_Static_assert(sizeof(struct B048_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B048_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B048_extra_size) == 10, "");
_Static_assert(_Alignof(struct B048_extra_size) == 1, "");
_Static_assert(sizeof(B049) == 8, "");
_Static_assert(_Alignof(B049) == 2, "");
_Static_assert(sizeof(struct B049_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B049_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B049_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B049_extra_packed) == 1, "");
_Static_assert(sizeof(struct B049_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B049_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B049_extra_size) == 10, "");
_Static_assert(_Alignof(struct B049_extra_size) == 1, "");
_Static_assert(sizeof(B050) == 8, "");
_Static_assert(_Alignof(B050) == 2, "");
_Static_assert(sizeof(struct B050_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B050_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B050_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B050_extra_packed) == 1, "");
_Static_assert(sizeof(struct B050_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B050_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B050_extra_size) == 10, "");
_Static_assert(_Alignof(struct B050_extra_size) == 1, "");
_Static_assert(sizeof(B051) == 8, "");
_Static_assert(_Alignof(B051) == 2, "");
_Static_assert(sizeof(struct B051_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B051_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B051_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B051_extra_packed) == 1, "");
_Static_assert(sizeof(struct B051_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B051_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B051_extra_size) == 10, "");
_Static_assert(_Alignof(struct B051_extra_size) == 1, "");
_Static_assert(sizeof(B052) == 8, "");
_Static_assert(_Alignof(B052) == 2, "");
_Static_assert(sizeof(struct B052_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B052_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B052_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B052_extra_packed) == 1, "");
_Static_assert(sizeof(struct B052_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B052_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B052_extra_size) == 10, "");
_Static_assert(_Alignof(struct B052_extra_size) == 1, "");
_Static_assert(sizeof(B053) == 8, "");
_Static_assert(_Alignof(B053) == 2, "");
_Static_assert(sizeof(struct B053_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B053_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B053_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B053_extra_packed) == 1, "");
_Static_assert(sizeof(struct B053_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B053_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B053_extra_size) == 10, "");
_Static_assert(_Alignof(struct B053_extra_size) == 1, "");
_Static_assert(sizeof(B054) == 8, "");
_Static_assert(_Alignof(B054) == 2, "");
_Static_assert(sizeof(struct B054_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B054_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B054_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B054_extra_packed) == 1, "");
_Static_assert(sizeof(struct B054_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B054_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B054_extra_size) == 10, "");
_Static_assert(_Alignof(struct B054_extra_size) == 1, "");
_Static_assert(sizeof(B055) == 8, "");
_Static_assert(_Alignof(B055) == 2, "");
_Static_assert(sizeof(struct B055_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B055_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B055_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B055_extra_packed) == 1, "");
_Static_assert(sizeof(struct B055_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B055_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B055_extra_size) == 10, "");
_Static_assert(_Alignof(struct B055_extra_size) == 1, "");
_Static_assert(sizeof(B056) == 8, "");
_Static_assert(_Alignof(B056) == 2, "");
_Static_assert(sizeof(struct B056_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B056_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B056_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B056_extra_packed) == 1, "");
_Static_assert(sizeof(struct B056_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B056_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B056_extra_size) == 10, "");
_Static_assert(_Alignof(struct B056_extra_size) == 1, "");
_Static_assert(sizeof(B061) == 8, "");
_Static_assert(_Alignof(B061) == 2, "");
_Static_assert(sizeof(struct B061_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B061_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B061_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B061_extra_packed) == 1, "");
_Static_assert(sizeof(struct B061_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B061_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B061_extra_size) == 10, "");
_Static_assert(_Alignof(struct B061_extra_size) == 1, "");
_Static_assert(sizeof(B062) == 8, "");
_Static_assert(_Alignof(B062) == 2, "");
_Static_assert(sizeof(struct B062_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B062_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B062_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B062_extra_packed) == 1, "");
_Static_assert(sizeof(struct B062_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B062_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B062_extra_size) == 10, "");
_Static_assert(_Alignof(struct B062_extra_size) == 1, "");
_Static_assert(sizeof(B063) == 8, "");
_Static_assert(_Alignof(B063) == 2, "");
_Static_assert(sizeof(struct B063_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B063_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B063_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B063_extra_packed) == 1, "");
_Static_assert(sizeof(struct B063_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B063_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B063_extra_size) == 10, "");
_Static_assert(_Alignof(struct B063_extra_size) == 1, "");
_Static_assert(sizeof(B064) == 8, "");
_Static_assert(_Alignof(B064) == 2, "");
_Static_assert(sizeof(struct B064_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B064_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B064_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B064_extra_packed) == 1, "");
_Static_assert(sizeof(struct B064_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B064_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B064_extra_size) == 10, "");
_Static_assert(_Alignof(struct B064_extra_size) == 1, "");
_Static_assert(sizeof(B065) == 8, "");
_Static_assert(_Alignof(B065) == 2, "");
_Static_assert(sizeof(struct B065_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B065_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B065_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B065_extra_packed) == 1, "");
_Static_assert(sizeof(struct B065_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B065_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B065_extra_size) == 10, "");
_Static_assert(_Alignof(struct B065_extra_size) == 1, "");
_Static_assert(sizeof(B066) == 8, "");
_Static_assert(_Alignof(B066) == 2, "");
_Static_assert(sizeof(struct B066_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B066_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B066_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B066_extra_packed) == 1, "");
_Static_assert(sizeof(struct B066_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B066_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B066_extra_size) == 10, "");
_Static_assert(_Alignof(struct B066_extra_size) == 1, "");
_Static_assert(sizeof(B067) == 8, "");
_Static_assert(_Alignof(B067) == 2, "");
_Static_assert(sizeof(struct B067_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B067_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B067_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B067_extra_packed) == 1, "");
_Static_assert(sizeof(struct B067_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B067_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B067_extra_size) == 10, "");
_Static_assert(_Alignof(struct B067_extra_size) == 1, "");
_Static_assert(sizeof(B068) == 8, "");
_Static_assert(_Alignof(B068) == 2, "");
_Static_assert(sizeof(struct B068_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B068_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B068_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B068_extra_packed) == 1, "");
_Static_assert(sizeof(struct B068_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B068_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B068_extra_size) == 10, "");
_Static_assert(_Alignof(struct B068_extra_size) == 1, "");
_Static_assert(sizeof(B069) == 8, "");
_Static_assert(_Alignof(B069) == 2, "");
_Static_assert(sizeof(struct B069_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B069_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B069_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B069_extra_packed) == 1, "");
_Static_assert(sizeof(struct B069_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B069_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B069_extra_size) == 10, "");
_Static_assert(_Alignof(struct B069_extra_size) == 1, "");
_Static_assert(sizeof(B070) == 8, "");
_Static_assert(_Alignof(B070) == 2, "");
_Static_assert(sizeof(struct B070_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B070_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B070_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B070_extra_packed) == 1, "");
_Static_assert(sizeof(struct B070_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B070_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B070_extra_size) == 10, "");
_Static_assert(_Alignof(struct B070_extra_size) == 1, "");
_Static_assert(sizeof(B071) == 8, "");
_Static_assert(_Alignof(B071) == 2, "");
_Static_assert(sizeof(struct B071_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B071_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B071_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B071_extra_packed) == 1, "");
_Static_assert(sizeof(struct B071_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B071_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B071_extra_size) == 10, "");
_Static_assert(_Alignof(struct B071_extra_size) == 1, "");
_Static_assert(sizeof(B072) == 8, "");
_Static_assert(_Alignof(B072) == 2, "");
_Static_assert(sizeof(struct B072_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B072_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B072_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B072_extra_packed) == 1, "");
_Static_assert(sizeof(struct B072_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B072_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B072_extra_size) == 10, "");
_Static_assert(_Alignof(struct B072_extra_size) == 1, "");
_Static_assert(sizeof(B073) == 8, "");
_Static_assert(_Alignof(B073) == 2, "");
_Static_assert(sizeof(struct B073_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B073_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B073_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B073_extra_packed) == 1, "");
_Static_assert(sizeof(struct B073_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B073_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B073_extra_size) == 10, "");
_Static_assert(_Alignof(struct B073_extra_size) == 1, "");
_Static_assert(sizeof(B074) == 8, "");
_Static_assert(_Alignof(B074) == 2, "");
_Static_assert(sizeof(struct B074_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B074_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B074_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B074_extra_packed) == 1, "");
_Static_assert(sizeof(struct B074_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B074_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B074_extra_size) == 10, "");
_Static_assert(_Alignof(struct B074_extra_size) == 1, "");
_Static_assert(sizeof(B075) == 8, "");
_Static_assert(_Alignof(B075) == 2, "");
_Static_assert(sizeof(struct B075_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B075_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B075_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B075_extra_packed) == 1, "");
_Static_assert(sizeof(struct B075_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B075_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B075_extra_size) == 10, "");
_Static_assert(_Alignof(struct B075_extra_size) == 1, "");
_Static_assert(sizeof(B076) == 8, "");
_Static_assert(_Alignof(B076) == 2, "");
_Static_assert(sizeof(struct B076_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B076_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B076_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B076_extra_packed) == 1, "");
_Static_assert(sizeof(struct B076_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B076_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B076_extra_size) == 10, "");
_Static_assert(_Alignof(struct B076_extra_size) == 1, "");
_Static_assert(sizeof(B081) == 2, "");
_Static_assert(_Alignof(B081) == 2, "");
_Static_assert(sizeof(struct B081_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B081_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B081_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B081_extra_packed) == 1, "");
_Static_assert(sizeof(struct B081_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B081_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B081_extra_size) == 4, "");
_Static_assert(_Alignof(struct B081_extra_size) == 1, "");
_Static_assert(sizeof(B082) == 2, "");
_Static_assert(_Alignof(B082) == 2, "");
_Static_assert(sizeof(struct B082_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B082_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B082_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B082_extra_packed) == 1, "");
_Static_assert(sizeof(struct B082_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B082_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B082_extra_size) == 4, "");
_Static_assert(_Alignof(struct B082_extra_size) == 1, "");
_Static_assert(sizeof(B083) == 2, "");
_Static_assert(_Alignof(B083) == 2, "");
_Static_assert(sizeof(struct B083_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B083_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B083_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B083_extra_packed) == 1, "");
_Static_assert(sizeof(struct B083_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B083_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B083_extra_size) == 4, "");
_Static_assert(_Alignof(struct B083_extra_size) == 1, "");
_Static_assert(sizeof(B084) == 2, "");
_Static_assert(_Alignof(B084) == 2, "");
_Static_assert(sizeof(struct B084_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B084_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B084_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B084_extra_packed) == 1, "");
_Static_assert(sizeof(struct B084_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B084_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B084_extra_size) == 4, "");
_Static_assert(_Alignof(struct B084_extra_size) == 1, "");
_Static_assert(sizeof(B085) == 2, "");
_Static_assert(_Alignof(B085) == 2, "");
_Static_assert(sizeof(struct B085_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B085_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B085_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B085_extra_packed) == 1, "");
_Static_assert(sizeof(struct B085_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B085_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B085_extra_size) == 4, "");
_Static_assert(_Alignof(struct B085_extra_size) == 1, "");
_Static_assert(sizeof(B086) == 2, "");
_Static_assert(_Alignof(B086) == 2, "");
_Static_assert(sizeof(struct B086_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B086_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B086_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B086_extra_packed) == 1, "");
_Static_assert(sizeof(struct B086_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B086_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B086_extra_size) == 4, "");
_Static_assert(_Alignof(struct B086_extra_size) == 1, "");
_Static_assert(sizeof(B087) == 2, "");
_Static_assert(_Alignof(B087) == 2, "");
_Static_assert(sizeof(struct B087_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B087_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B087_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B087_extra_packed) == 1, "");
_Static_assert(sizeof(struct B087_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B087_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B087_extra_size) == 4, "");
_Static_assert(_Alignof(struct B087_extra_size) == 1, "");
_Static_assert(sizeof(B088) == 2, "");
_Static_assert(_Alignof(B088) == 2, "");
_Static_assert(sizeof(struct B088_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B088_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B088_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B088_extra_packed) == 1, "");
_Static_assert(sizeof(struct B088_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B088_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B088_extra_size) == 4, "");
_Static_assert(_Alignof(struct B088_extra_size) == 1, "");
_Static_assert(sizeof(B089) == 2, "");
_Static_assert(_Alignof(B089) == 2, "");
_Static_assert(sizeof(struct B089_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B089_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B089_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B089_extra_packed) == 1, "");
_Static_assert(sizeof(struct B089_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B089_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B089_extra_size) == 4, "");
_Static_assert(_Alignof(struct B089_extra_size) == 1, "");
_Static_assert(sizeof(B090) == 2, "");
_Static_assert(_Alignof(B090) == 2, "");
_Static_assert(sizeof(struct B090_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B090_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B090_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B090_extra_packed) == 1, "");
_Static_assert(sizeof(struct B090_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B090_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B090_extra_size) == 4, "");
_Static_assert(_Alignof(struct B090_extra_size) == 1, "");
_Static_assert(sizeof(B091) == 2, "");
_Static_assert(_Alignof(B091) == 2, "");
_Static_assert(sizeof(struct B091_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B091_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B091_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B091_extra_packed) == 1, "");
_Static_assert(sizeof(struct B091_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B091_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B091_extra_size) == 4, "");
_Static_assert(_Alignof(struct B091_extra_size) == 1, "");
_Static_assert(sizeof(B092) == 2, "");
_Static_assert(_Alignof(B092) == 2, "");
_Static_assert(sizeof(struct B092_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B092_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B092_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B092_extra_packed) == 1, "");
_Static_assert(sizeof(struct B092_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B092_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B092_extra_size) == 4, "");
_Static_assert(_Alignof(struct B092_extra_size) == 1, "");
_Static_assert(sizeof(B093) == 2, "");
_Static_assert(_Alignof(B093) == 2, "");
_Static_assert(sizeof(struct B093_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B093_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B093_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B093_extra_packed) == 1, "");
_Static_assert(sizeof(struct B093_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B093_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B093_extra_size) == 4, "");
_Static_assert(_Alignof(struct B093_extra_size) == 1, "");
_Static_assert(sizeof(B094) == 2, "");
_Static_assert(_Alignof(B094) == 2, "");
_Static_assert(sizeof(struct B094_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B094_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B094_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B094_extra_packed) == 1, "");
_Static_assert(sizeof(struct B094_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B094_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B094_extra_size) == 4, "");
_Static_assert(_Alignof(struct B094_extra_size) == 1, "");
_Static_assert(sizeof(B095) == 2, "");
_Static_assert(_Alignof(B095) == 2, "");
_Static_assert(sizeof(struct B095_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B095_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B095_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B095_extra_packed) == 1, "");
_Static_assert(sizeof(struct B095_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B095_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B095_extra_size) == 4, "");
_Static_assert(_Alignof(struct B095_extra_size) == 1, "");
_Static_assert(sizeof(B096) == 2, "");
_Static_assert(_Alignof(B096) == 2, "");
_Static_assert(sizeof(struct B096_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B096_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B096_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B096_extra_packed) == 1, "");
_Static_assert(sizeof(struct B096_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B096_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B096_extra_size) == 4, "");
_Static_assert(_Alignof(struct B096_extra_size) == 1, "");
_Static_assert(sizeof(B101) == 4, "");
_Static_assert(_Alignof(B101) == 2, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 6, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
_Static_assert(sizeof(B102) == 4, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 6, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 2, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 2, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 4, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 6, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
_Static_assert(sizeof(B106) == 4, "");
_Static_assert(_Alignof(B106) == 2, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 6, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
_Static_assert(sizeof(B107) == 4, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 6, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 2, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
_Static_assert(sizeof(B109) == 4, "");
_Static_assert(_Alignof(B109) == 2, "");
_Static_assert(sizeof(struct B109_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B109_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B109_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B109_extra_packed) == 1, "");
_Static_assert(sizeof(struct B109_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B109_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B109_extra_size) == 6, "");
_Static_assert(_Alignof(struct B109_extra_size) == 1, "");
_Static_assert(sizeof(B110) == 4, "");
_Static_assert(_Alignof(B110) == 2, "");
_Static_assert(sizeof(struct B110_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B110_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B110_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B110_extra_packed) == 1, "");
_Static_assert(sizeof(struct B110_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B110_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B110_extra_size) == 6, "");
_Static_assert(_Alignof(struct B110_extra_size) == 1, "");
_Static_assert(sizeof(B111) == 4, "");
_Static_assert(_Alignof(B111) == 2, "");
_Static_assert(sizeof(struct B111_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B111_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B111_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B111_extra_packed) == 1, "");
_Static_assert(sizeof(struct B111_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B111_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B111_extra_size) == 6, "");
_Static_assert(_Alignof(struct B111_extra_size) == 1, "");
_Static_assert(sizeof(B112) == 4, "");
_Static_assert(_Alignof(B112) == 2, "");
_Static_assert(sizeof(struct B112_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B112_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B112_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B112_extra_packed) == 1, "");
_Static_assert(sizeof(struct B112_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B112_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B112_extra_size) == 6, "");
_Static_assert(_Alignof(struct B112_extra_size) == 1, "");
_Static_assert(sizeof(B113) == 4, "");
_Static_assert(_Alignof(B113) == 2, "");
_Static_assert(sizeof(struct B113_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B113_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B113_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B113_extra_packed) == 1, "");
_Static_assert(sizeof(struct B113_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B113_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B113_extra_size) == 6, "");
_Static_assert(_Alignof(struct B113_extra_size) == 1, "");
_Static_assert(sizeof(B114) == 4, "");
_Static_assert(_Alignof(B114) == 2, "");
_Static_assert(sizeof(struct B114_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B114_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B114_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B114_extra_packed) == 1, "");
_Static_assert(sizeof(struct B114_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B114_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B114_extra_size) == 6, "");
_Static_assert(_Alignof(struct B114_extra_size) == 1, "");
_Static_assert(sizeof(B115) == 4, "");
_Static_assert(_Alignof(B115) == 2, "");
_Static_assert(sizeof(struct B115_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B115_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B115_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B115_extra_packed) == 1, "");
_Static_assert(sizeof(struct B115_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B115_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B115_extra_size) == 6, "");
_Static_assert(_Alignof(struct B115_extra_size) == 1, "");
_Static_assert(sizeof(B116) == 4, "");
_Static_assert(_Alignof(B116) == 2, "");
_Static_assert(sizeof(struct B116_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B116_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B116_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B116_extra_packed) == 1, "");
_Static_assert(sizeof(struct B116_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B116_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B116_extra_size) == 6, "");
_Static_assert(_Alignof(struct B116_extra_size) == 1, "");
_Static_assert(sizeof(B121) == 8, "");
_Static_assert(_Alignof(B121) == 2, "");
_Static_assert(sizeof(struct B121_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B121_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B121_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B121_extra_packed) == 1, "");
_Static_assert(sizeof(struct B121_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B121_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B121_extra_size) == 10, "");
_Static_assert(_Alignof(struct B121_extra_size) == 1, "");
_Static_assert(sizeof(B122) == 8, "");
_Static_assert(_Alignof(B122) == 2, "");
_Static_assert(sizeof(struct B122_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B122_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B122_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B122_extra_packed) == 1, "");
_Static_assert(sizeof(struct B122_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B122_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B122_extra_size) == 10, "");
_Static_assert(_Alignof(struct B122_extra_size) == 1, "");
_Static_assert(sizeof(B123) == 8, "");
_Static_assert(_Alignof(B123) == 2, "");
_Static_assert(sizeof(struct B123_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B123_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B123_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B123_extra_packed) == 1, "");
_Static_assert(sizeof(struct B123_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B123_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B123_extra_size) == 10, "");
_Static_assert(_Alignof(struct B123_extra_size) == 1, "");
_Static_assert(sizeof(B124) == 8, "");
_Static_assert(_Alignof(B124) == 2, "");
_Static_assert(sizeof(struct B124_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B124_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B124_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B124_extra_packed) == 1, "");
_Static_assert(sizeof(struct B124_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B124_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B124_extra_size) == 10, "");
_Static_assert(_Alignof(struct B124_extra_size) == 1, "");
_Static_assert(sizeof(B125) == 8, "");
_Static_assert(_Alignof(B125) == 2, "");
_Static_assert(sizeof(struct B125_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B125_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B125_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B125_extra_packed) == 1, "");
_Static_assert(sizeof(struct B125_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B125_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B125_extra_size) == 10, "");
_Static_assert(_Alignof(struct B125_extra_size) == 1, "");
_Static_assert(sizeof(B126) == 8, "");
_Static_assert(_Alignof(B126) == 2, "");
_Static_assert(sizeof(struct B126_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B126_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B126_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B126_extra_packed) == 1, "");
_Static_assert(sizeof(struct B126_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B126_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B126_extra_size) == 10, "");
_Static_assert(_Alignof(struct B126_extra_size) == 1, "");
_Static_assert(sizeof(B127) == 8, "");
_Static_assert(_Alignof(B127) == 2, "");
_Static_assert(sizeof(struct B127_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B127_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B127_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B127_extra_packed) == 1, "");
_Static_assert(sizeof(struct B127_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B127_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B127_extra_size) == 10, "");
_Static_assert(_Alignof(struct B127_extra_size) == 1, "");
_Static_assert(sizeof(B128) == 8, "");
_Static_assert(_Alignof(B128) == 2, "");
_Static_assert(sizeof(struct B128_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B128_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B128_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B128_extra_packed) == 1, "");
_Static_assert(sizeof(struct B128_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B128_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B128_extra_size) == 10, "");
_Static_assert(_Alignof(struct B128_extra_size) == 1, "");
_Static_assert(sizeof(B129) == 8, "");
_Static_assert(_Alignof(B129) == 2, "");
_Static_assert(sizeof(struct B129_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B129_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B129_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B129_extra_packed) == 1, "");
_Static_assert(sizeof(struct B129_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B129_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B129_extra_size) == 10, "");
_Static_assert(_Alignof(struct B129_extra_size) == 1, "");
_Static_assert(sizeof(B130) == 8, "");
_Static_assert(_Alignof(B130) == 2, "");
_Static_assert(sizeof(struct B130_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B130_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B130_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B130_extra_packed) == 1, "");
_Static_assert(sizeof(struct B130_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B130_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B130_extra_size) == 10, "");
_Static_assert(_Alignof(struct B130_extra_size) == 1, "");
_Static_assert(sizeof(B131) == 8, "");
_Static_assert(_Alignof(B131) == 2, "");
_Static_assert(sizeof(struct B131_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B131_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B131_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B131_extra_packed) == 1, "");
_Static_assert(sizeof(struct B131_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B131_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B131_extra_size) == 10, "");
_Static_assert(_Alignof(struct B131_extra_size) == 1, "");
_Static_assert(sizeof(B132) == 8, "");
_Static_assert(_Alignof(B132) == 2, "");
_Static_assert(sizeof(struct B132_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B132_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B132_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B132_extra_packed) == 1, "");
_Static_assert(sizeof(struct B132_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B132_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B132_extra_size) == 10, "");
_Static_assert(_Alignof(struct B132_extra_size) == 1, "");
_Static_assert(sizeof(B133) == 8, "");
_Static_assert(_Alignof(B133) == 2, "");
_Static_assert(sizeof(struct B133_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B133_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B133_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B133_extra_packed) == 1, "");
_Static_assert(sizeof(struct B133_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B133_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B133_extra_size) == 10, "");
_Static_assert(_Alignof(struct B133_extra_size) == 1, "");
_Static_assert(sizeof(B134) == 8, "");
_Static_assert(_Alignof(B134) == 2, "");
_Static_assert(sizeof(struct B134_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B134_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B134_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B134_extra_packed) == 1, "");
_Static_assert(sizeof(struct B134_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B134_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B134_extra_size) == 10, "");
_Static_assert(_Alignof(struct B134_extra_size) == 1, "");
_Static_assert(sizeof(B135) == 8, "");
_Static_assert(_Alignof(B135) == 2, "");
_Static_assert(sizeof(struct B135_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B135_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B135_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B135_extra_packed) == 1, "");
_Static_assert(sizeof(struct B135_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B135_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B135_extra_size) == 10, "");
_Static_assert(_Alignof(struct B135_extra_size) == 1, "");
_Static_assert(sizeof(B136) == 8, "");
_Static_assert(_Alignof(B136) == 2, "");
_Static_assert(sizeof(struct B136_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B136_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B136_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B136_extra_packed) == 1, "");
_Static_assert(sizeof(struct B136_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B136_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B136_extra_size) == 10, "");
_Static_assert(_Alignof(struct B136_extra_size) == 1, "");
_Static_assert(sizeof(B141) == 8, "");
_Static_assert(_Alignof(B141) == 2, "");
_Static_assert(sizeof(struct B141_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B141_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B141_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B141_extra_packed) == 1, "");
_Static_assert(sizeof(struct B141_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B141_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B141_extra_size) == 10, "");
_Static_assert(_Alignof(struct B141_extra_size) == 1, "");
_Static_assert(sizeof(B142) == 8, "");
_Static_assert(_Alignof(B142) == 2, "");
_Static_assert(sizeof(struct B142_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B142_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B142_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B142_extra_packed) == 1, "");
_Static_assert(sizeof(struct B142_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B142_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B142_extra_size) == 10, "");
_Static_assert(_Alignof(struct B142_extra_size) == 1, "");
_Static_assert(sizeof(B143) == 8, "");
_Static_assert(_Alignof(B143) == 2, "");
_Static_assert(sizeof(struct B143_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B143_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B143_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B143_extra_packed) == 1, "");
_Static_assert(sizeof(struct B143_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B143_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B143_extra_size) == 10, "");
_Static_assert(_Alignof(struct B143_extra_size) == 1, "");
_Static_assert(sizeof(B144) == 8, "");
_Static_assert(_Alignof(B144) == 2, "");
_Static_assert(sizeof(struct B144_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B144_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B144_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B144_extra_packed) == 1, "");
_Static_assert(sizeof(struct B144_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B144_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B144_extra_size) == 10, "");
_Static_assert(_Alignof(struct B144_extra_size) == 1, "");
_Static_assert(sizeof(B145) == 8, "");
_Static_assert(_Alignof(B145) == 2, "");
_Static_assert(sizeof(struct B145_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B145_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B145_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B145_extra_packed) == 1, "");
_Static_assert(sizeof(struct B145_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B145_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B145_extra_size) == 10, "");
_Static_assert(_Alignof(struct B145_extra_size) == 1, "");
_Static_assert(sizeof(B146) == 8, "");
_Static_assert(_Alignof(B146) == 2, "");
_Static_assert(sizeof(struct B146_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B146_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B146_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B146_extra_packed) == 1, "");
_Static_assert(sizeof(struct B146_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B146_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B146_extra_size) == 10, "");
_Static_assert(_Alignof(struct B146_extra_size) == 1, "");
_Static_assert(sizeof(B147) == 8, "");
_Static_assert(_Alignof(B147) == 2, "");
_Static_assert(sizeof(struct B147_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B147_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B147_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B147_extra_packed) == 1, "");
_Static_assert(sizeof(struct B147_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B147_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B147_extra_size) == 10, "");
_Static_assert(_Alignof(struct B147_extra_size) == 1, "");
_Static_assert(sizeof(B148) == 8, "");
_Static_assert(_Alignof(B148) == 2, "");
_Static_assert(sizeof(struct B148_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B148_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B148_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B148_extra_packed) == 1, "");
_Static_assert(sizeof(struct B148_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B148_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B148_extra_size) == 10, "");
_Static_assert(_Alignof(struct B148_extra_size) == 1, "");
_Static_assert(sizeof(B149) == 8, "");
_Static_assert(_Alignof(B149) == 2, "");
_Static_assert(sizeof(struct B149_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B149_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B149_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B149_extra_packed) == 1, "");
_Static_assert(sizeof(struct B149_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B149_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B149_extra_size) == 10, "");
_Static_assert(_Alignof(struct B149_extra_size) == 1, "");
_Static_assert(sizeof(B150) == 8, "");
_Static_assert(_Alignof(B150) == 2, "");
_Static_assert(sizeof(struct B150_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B150_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B150_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B150_extra_packed) == 1, "");
_Static_assert(sizeof(struct B150_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B150_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B150_extra_size) == 10, "");
_Static_assert(_Alignof(struct B150_extra_size) == 1, "");
_Static_assert(sizeof(B151) == 8, "");
_Static_assert(_Alignof(B151) == 2, "");
_Static_assert(sizeof(struct B151_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B151_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B151_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B151_extra_packed) == 1, "");
_Static_assert(sizeof(struct B151_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B151_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B151_extra_size) == 10, "");
_Static_assert(_Alignof(struct B151_extra_size) == 1, "");
_Static_assert(sizeof(B152) == 8, "");
_Static_assert(_Alignof(B152) == 2, "");
_Static_assert(sizeof(struct B152_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B152_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B152_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B152_extra_packed) == 1, "");
_Static_assert(sizeof(struct B152_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B152_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B152_extra_size) == 10, "");
_Static_assert(_Alignof(struct B152_extra_size) == 1, "");
_Static_assert(sizeof(B153) == 8, "");
_Static_assert(_Alignof(B153) == 2, "");
_Static_assert(sizeof(struct B153_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B153_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B153_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B153_extra_packed) == 1, "");
_Static_assert(sizeof(struct B153_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B153_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B153_extra_size) == 10, "");
_Static_assert(_Alignof(struct B153_extra_size) == 1, "");
_Static_assert(sizeof(B154) == 8, "");
_Static_assert(_Alignof(B154) == 2, "");
_Static_assert(sizeof(struct B154_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B154_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B154_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B154_extra_packed) == 1, "");
_Static_assert(sizeof(struct B154_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B154_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B154_extra_size) == 10, "");
_Static_assert(_Alignof(struct B154_extra_size) == 1, "");
_Static_assert(sizeof(B155) == 8, "");
_Static_assert(_Alignof(B155) == 2, "");
_Static_assert(sizeof(struct B155_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B155_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B155_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B155_extra_packed) == 1, "");
_Static_assert(sizeof(struct B155_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B155_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B155_extra_size) == 10, "");
_Static_assert(_Alignof(struct B155_extra_size) == 1, "");
_Static_assert(sizeof(B156) == 8, "");
_Static_assert(_Alignof(B156) == 2, "");
_Static_assert(sizeof(struct B156_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B156_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B156_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B156_extra_packed) == 1, "");
_Static_assert(sizeof(struct B156_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B156_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B156_extra_size) == 10, "");
_Static_assert(_Alignof(struct B156_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0081_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(2)) typedef long long F;
#else
typedef long long F __attribute__((aligned(2)));
#endif
F var1;
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var2;
#pragma pack(1)
struct F_extra_packed {
#ifdef MSVC
char a[sizeof(F)];
#else
F a;
#endif
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var3;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var4;
typedef struct {
F c:15;
F d:64;
} G;
G var5;
struct G_extra_alignment {
char a;
G b;
};
struct G_extra_alignment var6;
#pragma pack(1)
struct G_extra_packed {
#ifdef MSVC
char a[sizeof(G)];
#else
G a;
#endif
};
#pragma pack()
struct G_extra_required_alignment {
char a;
struct G_extra_packed b;
};
struct G_extra_required_alignment var7;
struct G_extra_size {
char a[sizeof(G)+1];
char b;
};
struct G_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 10, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 10, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 12, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
#endif
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 8, "");
_Static_assert(sizeof(struct F_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 8, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 16, "");
_Static_assert(_Alignof(G) == 8, "");
_Static_assert(sizeof(struct G_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 8, "");
_Static_assert(sizeof(struct G_extra_packed) == 16, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 18, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 64, "");
#endif
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(THREE)
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 10, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 10, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 12, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 15, "");
#endif
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 10, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 10, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 12, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 15, "");
#endif
// MAPPING|FIVE|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(FIVE)
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 10, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 10, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 12, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
#endif
// MAPPING|SIX|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(SIX)
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 16, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 16, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 18, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 64, "");
#endif
// MAPPING|SEVEN|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SEVEN)
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 10, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 10, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 12, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0065_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(128)) typedef struct {
#else
typedef struct {
#endif
int x;
#ifdef MSVC
} A;
#else
} __attribute__((aligned(128))) A;
#endif
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
#ifdef MSVC
__declspec(align(128)) typedef union {
#else
typedef union {
#endif
int x;
#ifdef MSVC
} B;
#else
} __attribute__((aligned(128))) B;
#endif
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 128, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 130, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 128, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 130, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 128, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 130, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 128, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 130, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 128, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 130, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 128, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 130, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|FOUR|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 128, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 130, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 128, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 130, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0040_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c;
int:1;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
#pragma pack(1)
typedef struct {
char c;
int:1;
} B;
B var5;
#pragma pack()
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
#pragma pack(1)
typedef struct {
char c;
#ifdef MSVC
__declspec(align(8)) int:1;
#else
int:1 __attribute__((aligned(8)));
#endif
} C;
C var9;
#pragma pack()
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(THREE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 5, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 5, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 7, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 12, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 12, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 14, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FIVE|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 5, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 5, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 7, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 5, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 5, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 7, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0075_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(1)
typedef struct {
char c;
int:0;
char d;
} __attribute__((packed)) A;
A var1;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
A a;
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
#pragma pack(1)
typedef union {
char c;
char:0;
char d;
} __attribute__((packed)) B;
B var5;
#pragma pack()
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
B a;
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
#pragma pack(1)
typedef struct {
char c;
int:0 __attribute__((aligned(16)));
char d;
} __attribute__((packed)) C;
C var9;
#pragma pack()
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
C a;
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
#pragma pack(1)
typedef union {
char c;
char:0 __attribute__((aligned(16)));
char d;
} __attribute__((packed)) D;
D var13;
#pragma pack()
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var14;
#pragma pack(1)
struct D_extra_packed {
D a;
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var15;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var16;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 5, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 5, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 7, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(C) == 17, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 17, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 19, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 128, "");
#endif
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 0, "");
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(C) == 32, "");
_Static_assert(_Alignof(C) == 16, "");
_Static_assert(sizeof(struct C_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 16, "");
_Static_assert(sizeof(struct C_extra_packed) == 32, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 34, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 128, "");
#endif
_Static_assert(sizeof(D) == 16, "");
_Static_assert(_Alignof(D) == 16, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 18, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 0, "");
#endif
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(THREE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(C) == 32, "");
_Static_assert(_Alignof(C) == 16, "");
_Static_assert(sizeof(struct C_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 16, "");
_Static_assert(sizeof(struct C_extra_packed) == 32, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 34, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 128, "");
#endif
_Static_assert(sizeof(D) == 16, "");
_Static_assert(_Alignof(D) == 16, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 18, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 0, "");
#endif
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 8, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(C) == 32, "");
_Static_assert(_Alignof(C) == 16, "");
_Static_assert(sizeof(struct C_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 16, "");
_Static_assert(sizeof(struct C_extra_packed) == 32, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 34, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 128, "");
#endif
_Static_assert(sizeof(D) == 16, "");
_Static_assert(_Alignof(D) == 16, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 18, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 0, "");
#endif
// MAPPING|FIVE|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 8, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 8, "");
#endif
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 0, "");
#endif
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A) == 3, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 5, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 16, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(C) == 17, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 17, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 19, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 128, "");
#endif
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 0, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0016_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(1)
#ifdef MSVC
__declspec(align(128)) typedef enum {
#else
typedef enum {
#endif
F1 = 1,
F2 = 2,
F3 = 3,
#ifdef MSVC
} A;
#else
} __attribute__((aligned(128))) A;
#endif
A var4;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var5;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var6;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var7;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-netbsd-eabihf:Clang|x86-pentium4-ios-none:Clang|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-other-none:Clang|powerpc64-ppc64-freebsd-gnu:Clang|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv64-baseline_rv64-other-eabi:Clang|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") I386AppleIos|Some("x86-pentium4-ios-none") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownNone|Some("mipsel-mips32-other-none") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|THREE|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-windows-gnu:Gcc|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|END
// repr targets Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl")
#elif defined(THREE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|FIVE|hexagon-generic-linux-musl:Clang|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0078_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
int:1;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef union {
int:1;
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|x86-i686-windows-gnu:Gcc|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") I686PcWindowsGnu|Some("x86-i686-windows-gnu") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(THREE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0006_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(8)) typedef int Int;
#else
typedef int Int __attribute__((aligned(8)));
#endif
Int var1;
struct Int_extra_alignment {
char a;
Int b;
};
struct Int_extra_alignment var2;
#pragma pack(1)
struct Int_extra_packed {
#ifdef MSVC
char a[sizeof(Int)];
#else
Int a;
#endif
};
#pragma pack()
struct Int_extra_required_alignment {
char a;
struct Int_extra_packed b;
};
struct Int_extra_required_alignment var3;
struct Int_extra_size {
char a[sizeof(Int)+1];
char b;
};
struct Int_extra_size var4;
typedef struct {
int i:1;
Int j:1;
} X;
X var5;
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var6;
#pragma pack(1)
struct X_extra_packed {
#ifdef MSVC
char a[sizeof(X)];
#else
X a;
#endif
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var7;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-other-none:Clang|powerpc64-ppc64-freebsd-gnu:Clang|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv64-baseline_rv64-other-eabi:Clang|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownNone|Some("mipsel-mips32-other-none") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(Int) == 4, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 6, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 8, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 8, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 10, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,j) == 1, "");
#endif
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(Int) == 4, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 6, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 4, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 4, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 6, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,j) == 1, "");
#endif
// MAPPING|THREE|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|END
// repr targets Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl")
#elif defined(THREE)
_Static_assert(sizeof(Int) == 4, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 6, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 16, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 18, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,j) == 64, "");
#endif
// MAPPING|FOUR|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(FOUR)
_Static_assert(sizeof(Int) == 4, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 6, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 1, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 3, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,j) == 1, "");
#endif
// MAPPING|FIVE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(Int) == 2, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 4, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 1, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 3, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,j) == 1, "");
#endif
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(Int) == 2, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 4, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 8, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 8, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 10, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,j) == 1, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0030_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(2)
typedef struct {
char c;
int i;
} A;
A var1;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
#ifdef MSVC
__declspec(align(8)) int i:1;
#else
int i:1 __attribute__((aligned(8)));
#endif
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
#pragma pack(2)
typedef struct {
char c;
B b;
} C;
C var9;
#pragma pack()
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-windows-msvc:Msvc|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-windows-msvc:Msvc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|x86-i686-uefi-msvc:Msvc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-baseline-windows-msvc:Msvc|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") I686UnknownWindows|Some("x86-i686-uefi-msvc") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#ifdef ONE
_Static_assert(sizeof(A) == 6, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 8, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,i) == 16, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 10, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 10, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 12, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 16, "");
#endif
// MAPPING|TWO|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 3, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 3, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 5, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,i) == 8, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 10, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 10, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 12, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 16, "");
#endif
// MAPPING|THREE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,i) == 16, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 10, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 10, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 12, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 16, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0035_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef union {
int:0;
char:1;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef union {
char:1;
int:0;
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
typedef struct {
char a;
long:0;
} C;
C var9;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
typedef struct {
char:0;
long:0;
} D;
D var13;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var14;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var15;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var16;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(THREE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 4, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 6, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FOUR|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FIVE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|SIX|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-linux-gnux32:Gcc|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32")
#elif defined(SIX)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|SEVEN|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(SEVEN)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|EIGHT|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(EIGHT)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0013_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef char A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef unsigned char B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
typedef signed char C;
C var9;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
typedef unsigned short D;
D var13;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var14;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var15;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var16;
typedef short E;
E var17;
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var18;
#pragma pack(1)
struct E_extra_packed {
#ifdef MSVC
char a[sizeof(E)];
#else
E a;
#endif
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var19;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var20;
typedef unsigned int F;
F var21;
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var22;
#pragma pack(1)
struct F_extra_packed {
#ifdef MSVC
char a[sizeof(F)];
#else
F a;
#endif
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var23;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var24;
typedef int G;
G var25;
struct G_extra_alignment {
char a;
G b;
};
struct G_extra_alignment var26;
#pragma pack(1)
struct G_extra_packed {
#ifdef MSVC
char a[sizeof(G)];
#else
G a;
#endif
};
#pragma pack()
struct G_extra_required_alignment {
char a;
struct G_extra_packed b;
};
struct G_extra_required_alignment var27;
struct G_extra_size {
char a[sizeof(G)+1];
char b;
};
struct G_extra_size var28;
typedef unsigned long H;
H var29;
struct H_extra_alignment {
char a;
H b;
};
struct H_extra_alignment var30;
#pragma pack(1)
struct H_extra_packed {
#ifdef MSVC
char a[sizeof(H)];
#else
H a;
#endif
};
#pragma pack()
struct H_extra_required_alignment {
char a;
struct H_extra_packed b;
};
struct H_extra_required_alignment var31;
struct H_extra_size {
char a[sizeof(H)+1];
char b;
};
struct H_extra_size var32;
typedef long I;
I var33;
struct I_extra_alignment {
char a;
I b;
};
struct I_extra_alignment var34;
#pragma pack(1)
struct I_extra_packed {
#ifdef MSVC
char a[sizeof(I)];
#else
I a;
#endif
};
#pragma pack()
struct I_extra_required_alignment {
char a;
struct I_extra_packed b;
};
struct I_extra_required_alignment var35;
struct I_extra_size {
char a[sizeof(I)+1];
char b;
};
struct I_extra_size var36;
typedef unsigned long long J;
J var37;
struct J_extra_alignment {
char a;
J b;
};
struct J_extra_alignment var38;
#pragma pack(1)
struct J_extra_packed {
#ifdef MSVC
char a[sizeof(J)];
#else
J a;
#endif
};
#pragma pack()
struct J_extra_required_alignment {
char a;
struct J_extra_packed b;
};
struct J_extra_required_alignment var39;
struct J_extra_size {
char a[sizeof(J)+1];
char b;
};
struct J_extra_size var40;
typedef long long K;
K var41;
struct K_extra_alignment {
char a;
K b;
};
struct K_extra_alignment var42;
#pragma pack(1)
struct K_extra_packed {
#ifdef MSVC
char a[sizeof(K)];
#else
K a;
#endif
};
#pragma pack()
struct K_extra_required_alignment {
char a;
struct K_extra_packed b;
};
struct K_extra_required_alignment var43;
struct K_extra_size {
char a[sizeof(K)+1];
char b;
};
struct K_extra_size var44;
typedef void* L;
L var45;
struct L_extra_alignment {
char a;
L b;
};
struct L_extra_alignment var46;
#pragma pack(1)
struct L_extra_packed {
#ifdef MSVC
char a[sizeof(L)];
#else
L a;
#endif
};
#pragma pack()
struct L_extra_required_alignment {
char a;
struct L_extra_packed b;
};
struct L_extra_required_alignment var47;
struct L_extra_size {
char a[sizeof(L)+1];
char b;
};
struct L_extra_size var48;
typedef float M;
M var49;
struct M_extra_alignment {
char a;
M b;
};
struct M_extra_alignment var50;
#pragma pack(1)
struct M_extra_packed {
#ifdef MSVC
char a[sizeof(M)];
#else
M a;
#endif
};
#pragma pack()
struct M_extra_required_alignment {
char a;
struct M_extra_packed b;
};
struct M_extra_required_alignment var51;
struct M_extra_size {
char a[sizeof(M)+1];
char b;
};
struct M_extra_size var52;
typedef double N;
N var53;
struct N_extra_alignment {
char a;
N b;
};
struct N_extra_alignment var54;
#pragma pack(1)
struct N_extra_packed {
#ifdef MSVC
char a[sizeof(N)];
#else
N a;
#endif
};
#pragma pack()
struct N_extra_required_alignment {
char a;
struct N_extra_packed b;
};
struct N_extra_required_alignment var55;
struct N_extra_size {
char a[sizeof(N)+1];
char b;
};
struct N_extra_size var56;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 4, "");
_Static_assert(_Alignof(F) == 4, "");
_Static_assert(sizeof(struct F_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 6, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 4, "");
_Static_assert(_Alignof(G) == 4, "");
_Static_assert(sizeof(struct G_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 4, "");
_Static_assert(sizeof(struct G_extra_packed) == 4, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 6, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 8, "");
_Static_assert(_Alignof(H) == 8, "");
_Static_assert(sizeof(struct H_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 8, "");
_Static_assert(sizeof(struct H_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 10, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 8, "");
_Static_assert(_Alignof(I) == 8, "");
_Static_assert(sizeof(struct I_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 8, "");
_Static_assert(sizeof(struct I_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 10, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 8, "");
_Static_assert(_Alignof(J) == 8, "");
_Static_assert(sizeof(struct J_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 8, "");
_Static_assert(sizeof(struct J_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 10, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
_Static_assert(sizeof(L) == 8, "");
_Static_assert(_Alignof(L) == 8, "");
_Static_assert(sizeof(struct L_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 8, "");
_Static_assert(sizeof(struct L_extra_packed) == 8, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 10, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 4, "");
_Static_assert(sizeof(struct M_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 4, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
_Static_assert(sizeof(N) == 8, "");
_Static_assert(_Alignof(N) == 8, "");
_Static_assert(sizeof(struct N_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 8, "");
_Static_assert(sizeof(struct N_extra_packed) == 8, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 10, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 4, "");
_Static_assert(_Alignof(F) == 4, "");
_Static_assert(sizeof(struct F_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 6, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 4, "");
_Static_assert(_Alignof(G) == 4, "");
_Static_assert(sizeof(struct G_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 4, "");
_Static_assert(sizeof(struct G_extra_packed) == 4, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 6, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 4, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 4, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 6, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 4, "");
_Static_assert(_Alignof(I) == 4, "");
_Static_assert(sizeof(struct I_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 4, "");
_Static_assert(sizeof(struct I_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 6, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 8, "");
_Static_assert(_Alignof(J) == 8, "");
_Static_assert(sizeof(struct J_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 8, "");
_Static_assert(sizeof(struct J_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 10, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
_Static_assert(sizeof(L) == 8, "");
_Static_assert(_Alignof(L) == 8, "");
_Static_assert(sizeof(struct L_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 8, "");
_Static_assert(sizeof(struct L_extra_packed) == 8, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 10, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 4, "");
_Static_assert(sizeof(struct M_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 4, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
_Static_assert(sizeof(N) == 8, "");
_Static_assert(_Alignof(N) == 8, "");
_Static_assert(sizeof(struct N_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 8, "");
_Static_assert(sizeof(struct N_extra_packed) == 8, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 10, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
// MAPPING|THREE|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-i586-windows-msvc:Msvc|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-baseline-windows-msvc:Msvc|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-linux-gnux32:Gcc|END
// repr targets Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32")
#elif defined(THREE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 4, "");
_Static_assert(_Alignof(F) == 4, "");
_Static_assert(sizeof(struct F_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 6, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 4, "");
_Static_assert(_Alignof(G) == 4, "");
_Static_assert(sizeof(struct G_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 4, "");
_Static_assert(sizeof(struct G_extra_packed) == 4, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 6, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 4, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 4, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 6, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 4, "");
_Static_assert(_Alignof(I) == 4, "");
_Static_assert(sizeof(struct I_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 4, "");
_Static_assert(sizeof(struct I_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 6, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 8, "");
_Static_assert(_Alignof(J) == 8, "");
_Static_assert(sizeof(struct J_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 8, "");
_Static_assert(sizeof(struct J_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 10, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
_Static_assert(sizeof(L) == 4, "");
_Static_assert(_Alignof(L) == 4, "");
_Static_assert(sizeof(struct L_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 4, "");
_Static_assert(sizeof(struct L_extra_packed) == 4, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 6, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 4, "");
_Static_assert(sizeof(struct M_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 4, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
_Static_assert(sizeof(N) == 8, "");
_Static_assert(_Alignof(N) == 8, "");
_Static_assert(sizeof(struct N_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 8, "");
_Static_assert(sizeof(struct N_extra_packed) == 8, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 10, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
// MAPPING|FOUR|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 4, "");
_Static_assert(_Alignof(F) == 4, "");
_Static_assert(sizeof(struct F_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 6, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 4, "");
_Static_assert(_Alignof(G) == 4, "");
_Static_assert(sizeof(struct G_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 4, "");
_Static_assert(sizeof(struct G_extra_packed) == 4, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 6, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 4, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 4, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 6, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 4, "");
_Static_assert(_Alignof(I) == 4, "");
_Static_assert(sizeof(struct I_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 4, "");
_Static_assert(sizeof(struct I_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 6, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 8, "");
_Static_assert(_Alignof(J) == 4, "");
_Static_assert(sizeof(struct J_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 4, "");
_Static_assert(sizeof(struct J_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 10, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 4, "");
_Static_assert(sizeof(struct K_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 4, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
_Static_assert(sizeof(L) == 4, "");
_Static_assert(_Alignof(L) == 4, "");
_Static_assert(sizeof(struct L_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 4, "");
_Static_assert(sizeof(struct L_extra_packed) == 4, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 6, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 4, "");
_Static_assert(sizeof(struct M_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 4, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
_Static_assert(sizeof(N) == 8, "");
_Static_assert(_Alignof(N) == 4, "");
_Static_assert(sizeof(struct N_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 4, "");
_Static_assert(sizeof(struct N_extra_packed) == 8, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 10, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
// MAPPING|FIVE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 2, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 2, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 4, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 2, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 2, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 4, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 4, "");
_Static_assert(_Alignof(H) == 1, "");
_Static_assert(sizeof(struct H_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_packed) == 4, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 6, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 4, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 6, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 8, "");
_Static_assert(_Alignof(J) == 1, "");
_Static_assert(sizeof(struct J_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 10, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 1, "");
_Static_assert(sizeof(struct K_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
_Static_assert(sizeof(L) == 2, "");
_Static_assert(_Alignof(L) == 1, "");
_Static_assert(sizeof(struct L_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_packed) == 2, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 4, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 1, "");
_Static_assert(sizeof(struct M_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 1, "");
_Static_assert(sizeof(struct N_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 2, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 2, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 4, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 2, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 2, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 4, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 4, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 4, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 6, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 4, "");
_Static_assert(_Alignof(I) == 2, "");
_Static_assert(sizeof(struct I_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 2, "");
_Static_assert(sizeof(struct I_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 6, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 8, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 10, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 2, "");
_Static_assert(sizeof(struct K_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 2, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
_Static_assert(sizeof(L) == 2, "");
_Static_assert(_Alignof(L) == 2, "");
_Static_assert(sizeof(struct L_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 2, "");
_Static_assert(sizeof(struct L_extra_packed) == 2, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 4, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
_Static_assert(sizeof(N) == 8, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 8, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 10, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0007_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(8)) typedef short a;
#else
typedef short a __attribute__((aligned(8)));
#endif
a var1;
struct a_extra_alignment {
char a;
a b;
};
struct a_extra_alignment var2;
#pragma pack(1)
struct a_extra_packed {
#ifdef MSVC
char a[sizeof(a)];
#else
a a;
#endif
};
#pragma pack()
struct a_extra_required_alignment {
char a;
struct a_extra_packed b;
};
struct a_extra_required_alignment var3;
struct a_extra_size {
char a[sizeof(a)+1];
char b;
};
struct a_extra_size var4;
#pragma pack(4)
typedef struct {
a i:1;
} A;
A var5;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var6;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var7;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var8;
#ifdef MSVC
__declspec(align(4)) typedef short b;
#else
typedef short b __attribute__((aligned(4)));
#endif
b var9;
struct b_extra_alignment {
char a;
b b;
};
struct b_extra_alignment var10;
#pragma pack(1)
struct b_extra_packed {
#ifdef MSVC
char a[sizeof(b)];
#else
b a;
#endif
};
#pragma pack()
struct b_extra_required_alignment {
char a;
struct b_extra_packed b;
};
struct b_extra_required_alignment var11;
struct b_extra_size {
char a[sizeof(b)+1];
char b;
};
struct b_extra_size var12;
#pragma pack(8)
typedef struct {
b i:1;
} B;
B var13;
#pragma pack()
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var14;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var15;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var16;
#ifdef MSVC
__declspec(align(8)) typedef int c;
#else
typedef int c __attribute__((aligned(8)));
#endif
c var17;
struct c_extra_alignment {
char a;
c b;
};
struct c_extra_alignment var18;
#pragma pack(1)
struct c_extra_packed {
#ifdef MSVC
char a[sizeof(c)];
#else
c a;
#endif
};
#pragma pack()
struct c_extra_required_alignment {
char a;
struct c_extra_packed b;
};
struct c_extra_required_alignment var19;
struct c_extra_size {
char a[sizeof(c)+1];
char b;
};
struct c_extra_size var20;
#pragma pack(2)
typedef struct {
c i:1;
} C;
C var21;
#pragma pack()
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var22;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var23;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var24;
#ifdef MSVC
__declspec(align(4)) typedef long long d;
#else
typedef long long d __attribute__((aligned(4)));
#endif
d var25;
struct d_extra_alignment {
char a;
d b;
};
struct d_extra_alignment var26;
#pragma pack(1)
struct d_extra_packed {
#ifdef MSVC
char a[sizeof(d)];
#else
d a;
#endif
};
#pragma pack()
struct d_extra_required_alignment {
char a;
struct d_extra_packed b;
};
struct d_extra_required_alignment var27;
struct d_extra_size {
char a[sizeof(d)+1];
char b;
};
struct d_extra_size var28;
#pragma pack(2)
typedef struct {
d i:1;
} D;
D var29;
#pragma pack()
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var30;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var31;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var32;
#ifdef MSVC
__declspec(align(2)) typedef int e;
#else
typedef int e __attribute__((aligned(2)));
#endif
e var33;
struct e_extra_alignment {
char a;
e b;
};
struct e_extra_alignment var34;
#pragma pack(1)
struct e_extra_packed {
#ifdef MSVC
char a[sizeof(e)];
#else
e a;
#endif
};
#pragma pack()
struct e_extra_required_alignment {
char a;
struct e_extra_packed b;
};
struct e_extra_required_alignment var35;
struct e_extra_size {
char a[sizeof(e)+1];
char b;
};
struct e_extra_size var36;
#pragma pack(8)
typedef struct {
e i:1;
} E;
E var37;
#pragma pack()
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var38;
#pragma pack(1)
struct E_extra_packed {
#ifdef MSVC
char a[sizeof(E)];
#else
E a;
#endif
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var39;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var40;
#ifdef MSVC
__declspec(align(2)) typedef long long f;
#else
typedef long long f __attribute__((aligned(2)));
#endif
f var41;
struct f_extra_alignment {
char a;
f b;
};
struct f_extra_alignment var42;
#pragma pack(1)
struct f_extra_packed {
#ifdef MSVC
char a[sizeof(f)];
#else
f a;
#endif
};
#pragma pack()
struct f_extra_required_alignment {
char a;
struct f_extra_packed b;
};
struct f_extra_required_alignment var43;
struct f_extra_size {
char a[sizeof(f)+1];
char b;
};
struct f_extra_size var44;
#pragma pack(4)
typedef struct {
f i:1;
} F;
F var45;
#pragma pack()
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var46;
#pragma pack(1)
struct F_extra_packed {
#ifdef MSVC
char a[sizeof(F)];
#else
F a;
#endif
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var47;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var48;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(a) == 2, "");
_Static_assert(_Alignof(a) == 8, "");
_Static_assert(sizeof(struct a_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct a_extra_alignment) == 8, "");
_Static_assert(sizeof(struct a_extra_packed) == 2, "");
_Static_assert(_Alignof(struct a_extra_packed) == 1, "");
_Static_assert(sizeof(struct a_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct a_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct a_extra_size) == 4, "");
_Static_assert(_Alignof(struct a_extra_size) == 1, "");
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(b) == 2, "");
_Static_assert(_Alignof(b) == 4, "");
_Static_assert(sizeof(struct b_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct b_extra_alignment) == 4, "");
_Static_assert(sizeof(struct b_extra_packed) == 2, "");
_Static_assert(_Alignof(struct b_extra_packed) == 1, "");
_Static_assert(sizeof(struct b_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct b_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct b_extra_size) == 4, "");
_Static_assert(_Alignof(struct b_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(c) == 4, "");
_Static_assert(_Alignof(c) == 8, "");
_Static_assert(sizeof(struct c_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct c_extra_alignment) == 8, "");
_Static_assert(sizeof(struct c_extra_packed) == 4, "");
_Static_assert(_Alignof(struct c_extra_packed) == 1, "");
_Static_assert(sizeof(struct c_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct c_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct c_extra_size) == 6, "");
_Static_assert(_Alignof(struct c_extra_size) == 1, "");
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(d) == 8, "");
_Static_assert(_Alignof(d) == 4, "");
_Static_assert(sizeof(struct d_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct d_extra_alignment) == 4, "");
_Static_assert(sizeof(struct d_extra_packed) == 8, "");
_Static_assert(_Alignof(struct d_extra_packed) == 1, "");
_Static_assert(sizeof(struct d_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct d_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct d_extra_size) == 10, "");
_Static_assert(_Alignof(struct d_extra_size) == 1, "");
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(e) == 4, "");
_Static_assert(_Alignof(e) == 2, "");
_Static_assert(sizeof(struct e_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct e_extra_alignment) == 2, "");
_Static_assert(sizeof(struct e_extra_packed) == 4, "");
_Static_assert(_Alignof(struct e_extra_packed) == 1, "");
_Static_assert(sizeof(struct e_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct e_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct e_extra_size) == 6, "");
_Static_assert(_Alignof(struct e_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(f) == 8, "");
_Static_assert(_Alignof(f) == 2, "");
_Static_assert(sizeof(struct f_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct f_extra_alignment) == 2, "");
_Static_assert(sizeof(struct f_extra_packed) == 8, "");
_Static_assert(_Alignof(struct f_extra_packed) == 1, "");
_Static_assert(sizeof(struct f_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct f_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct f_extra_size) == 10, "");
_Static_assert(_Alignof(struct f_extra_size) == 1, "");
_Static_assert(sizeof(F) == 2, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 2, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 4, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(a) == 2, "");
_Static_assert(_Alignof(a) == 8, "");
_Static_assert(sizeof(struct a_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct a_extra_alignment) == 8, "");
_Static_assert(sizeof(struct a_extra_packed) == 2, "");
_Static_assert(_Alignof(struct a_extra_packed) == 1, "");
_Static_assert(sizeof(struct a_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct a_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct a_extra_size) == 4, "");
_Static_assert(_Alignof(struct a_extra_size) == 1, "");
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(b) == 2, "");
_Static_assert(_Alignof(b) == 4, "");
_Static_assert(sizeof(struct b_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct b_extra_alignment) == 4, "");
_Static_assert(sizeof(struct b_extra_packed) == 2, "");
_Static_assert(_Alignof(struct b_extra_packed) == 1, "");
_Static_assert(sizeof(struct b_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct b_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct b_extra_size) == 4, "");
_Static_assert(_Alignof(struct b_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(c) == 4, "");
_Static_assert(_Alignof(c) == 8, "");
_Static_assert(sizeof(struct c_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct c_extra_alignment) == 8, "");
_Static_assert(sizeof(struct c_extra_packed) == 4, "");
_Static_assert(_Alignof(struct c_extra_packed) == 1, "");
_Static_assert(sizeof(struct c_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct c_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct c_extra_size) == 6, "");
_Static_assert(_Alignof(struct c_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(d) == 8, "");
_Static_assert(_Alignof(d) == 8, "");
_Static_assert(sizeof(struct d_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct d_extra_alignment) == 8, "");
_Static_assert(sizeof(struct d_extra_packed) == 8, "");
_Static_assert(_Alignof(struct d_extra_packed) == 1, "");
_Static_assert(sizeof(struct d_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct d_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct d_extra_size) == 10, "");
_Static_assert(_Alignof(struct d_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(e) == 4, "");
_Static_assert(_Alignof(e) == 4, "");
_Static_assert(sizeof(struct e_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct e_extra_alignment) == 4, "");
_Static_assert(sizeof(struct e_extra_packed) == 4, "");
_Static_assert(_Alignof(struct e_extra_packed) == 1, "");
_Static_assert(sizeof(struct e_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct e_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct e_extra_size) == 6, "");
_Static_assert(_Alignof(struct e_extra_size) == 1, "");
_Static_assert(sizeof(E) == 4, "");
_Static_assert(_Alignof(E) == 4, "");
_Static_assert(sizeof(struct E_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 4, "");
_Static_assert(sizeof(struct E_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 6, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(f) == 8, "");
_Static_assert(_Alignof(f) == 8, "");
_Static_assert(sizeof(struct f_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct f_extra_alignment) == 8, "");
_Static_assert(sizeof(struct f_extra_packed) == 8, "");
_Static_assert(_Alignof(struct f_extra_packed) == 1, "");
_Static_assert(sizeof(struct f_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct f_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct f_extra_size) == 10, "");
_Static_assert(_Alignof(struct f_extra_size) == 1, "");
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 4, "");
_Static_assert(sizeof(struct F_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(THREE)
_Static_assert(sizeof(a) == 2, "");
_Static_assert(_Alignof(a) == 8, "");
_Static_assert(sizeof(struct a_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct a_extra_alignment) == 8, "");
_Static_assert(sizeof(struct a_extra_packed) == 2, "");
_Static_assert(_Alignof(struct a_extra_packed) == 1, "");
_Static_assert(sizeof(struct a_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct a_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct a_extra_size) == 4, "");
_Static_assert(_Alignof(struct a_extra_size) == 1, "");
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(b) == 2, "");
_Static_assert(_Alignof(b) == 4, "");
_Static_assert(sizeof(struct b_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct b_extra_alignment) == 4, "");
_Static_assert(sizeof(struct b_extra_packed) == 2, "");
_Static_assert(_Alignof(struct b_extra_packed) == 1, "");
_Static_assert(sizeof(struct b_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct b_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct b_extra_size) == 4, "");
_Static_assert(_Alignof(struct b_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(c) == 4, "");
_Static_assert(_Alignof(c) == 8, "");
_Static_assert(sizeof(struct c_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct c_extra_alignment) == 8, "");
_Static_assert(sizeof(struct c_extra_packed) == 4, "");
_Static_assert(_Alignof(struct c_extra_packed) == 1, "");
_Static_assert(sizeof(struct c_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct c_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct c_extra_size) == 6, "");
_Static_assert(_Alignof(struct c_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(d) == 8, "");
_Static_assert(_Alignof(d) == 4, "");
_Static_assert(sizeof(struct d_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct d_extra_alignment) == 4, "");
_Static_assert(sizeof(struct d_extra_packed) == 8, "");
_Static_assert(_Alignof(struct d_extra_packed) == 1, "");
_Static_assert(sizeof(struct d_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct d_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct d_extra_size) == 10, "");
_Static_assert(_Alignof(struct d_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(e) == 4, "");
_Static_assert(_Alignof(e) == 2, "");
_Static_assert(sizeof(struct e_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct e_extra_alignment) == 2, "");
_Static_assert(sizeof(struct e_extra_packed) == 4, "");
_Static_assert(_Alignof(struct e_extra_packed) == 1, "");
_Static_assert(sizeof(struct e_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct e_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct e_extra_size) == 6, "");
_Static_assert(_Alignof(struct e_extra_size) == 1, "");
_Static_assert(sizeof(E) == 1, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 3, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(f) == 8, "");
_Static_assert(_Alignof(f) == 2, "");
_Static_assert(sizeof(struct f_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct f_extra_alignment) == 2, "");
_Static_assert(sizeof(struct f_extra_packed) == 8, "");
_Static_assert(_Alignof(struct f_extra_packed) == 1, "");
_Static_assert(sizeof(struct f_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct f_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct f_extra_size) == 10, "");
_Static_assert(_Alignof(struct f_extra_size) == 1, "");
_Static_assert(sizeof(F) == 1, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 1, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 3, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(a) == 2, "");
_Static_assert(_Alignof(a) == 8, "");
_Static_assert(sizeof(struct a_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct a_extra_alignment) == 8, "");
_Static_assert(sizeof(struct a_extra_packed) == 2, "");
_Static_assert(_Alignof(struct a_extra_packed) == 1, "");
_Static_assert(sizeof(struct a_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct a_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct a_extra_size) == 4, "");
_Static_assert(_Alignof(struct a_extra_size) == 1, "");
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(b) == 2, "");
_Static_assert(_Alignof(b) == 4, "");
_Static_assert(sizeof(struct b_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct b_extra_alignment) == 4, "");
_Static_assert(sizeof(struct b_extra_packed) == 2, "");
_Static_assert(_Alignof(struct b_extra_packed) == 1, "");
_Static_assert(sizeof(struct b_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct b_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct b_extra_size) == 4, "");
_Static_assert(_Alignof(struct b_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(c) == 2, "");
_Static_assert(_Alignof(c) == 8, "");
_Static_assert(sizeof(struct c_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct c_extra_alignment) == 8, "");
_Static_assert(sizeof(struct c_extra_packed) == 2, "");
_Static_assert(_Alignof(struct c_extra_packed) == 1, "");
_Static_assert(sizeof(struct c_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct c_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct c_extra_size) == 4, "");
_Static_assert(_Alignof(struct c_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(d) == 8, "");
_Static_assert(_Alignof(d) == 4, "");
_Static_assert(sizeof(struct d_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct d_extra_alignment) == 4, "");
_Static_assert(sizeof(struct d_extra_packed) == 8, "");
_Static_assert(_Alignof(struct d_extra_packed) == 1, "");
_Static_assert(sizeof(struct d_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct d_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct d_extra_size) == 10, "");
_Static_assert(_Alignof(struct d_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(e) == 2, "");
_Static_assert(_Alignof(e) == 2, "");
_Static_assert(sizeof(struct e_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct e_extra_alignment) == 2, "");
_Static_assert(sizeof(struct e_extra_packed) == 2, "");
_Static_assert(_Alignof(struct e_extra_packed) == 1, "");
_Static_assert(sizeof(struct e_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct e_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct e_extra_size) == 4, "");
_Static_assert(_Alignof(struct e_extra_size) == 1, "");
_Static_assert(sizeof(E) == 1, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 3, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(f) == 8, "");
_Static_assert(_Alignof(f) == 2, "");
_Static_assert(sizeof(struct f_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct f_extra_alignment) == 2, "");
_Static_assert(sizeof(struct f_extra_packed) == 8, "");
_Static_assert(_Alignof(struct f_extra_packed) == 1, "");
_Static_assert(sizeof(struct f_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct f_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct f_extra_size) == 10, "");
_Static_assert(_Alignof(struct f_extra_size) == 1, "");
_Static_assert(sizeof(F) == 1, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 1, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 3, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
// MAPPING|FIVE|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(FIVE)
_Static_assert(sizeof(a) == 2, "");
_Static_assert(_Alignof(a) == 8, "");
_Static_assert(sizeof(struct a_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct a_extra_alignment) == 8, "");
_Static_assert(sizeof(struct a_extra_packed) == 2, "");
_Static_assert(_Alignof(struct a_extra_packed) == 1, "");
_Static_assert(sizeof(struct a_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct a_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct a_extra_size) == 4, "");
_Static_assert(_Alignof(struct a_extra_size) == 1, "");
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(b) == 2, "");
_Static_assert(_Alignof(b) == 4, "");
_Static_assert(sizeof(struct b_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct b_extra_alignment) == 4, "");
_Static_assert(sizeof(struct b_extra_packed) == 2, "");
_Static_assert(_Alignof(struct b_extra_packed) == 1, "");
_Static_assert(sizeof(struct b_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct b_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct b_extra_size) == 4, "");
_Static_assert(_Alignof(struct b_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(c) == 4, "");
_Static_assert(_Alignof(c) == 8, "");
_Static_assert(sizeof(struct c_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct c_extra_alignment) == 8, "");
_Static_assert(sizeof(struct c_extra_packed) == 4, "");
_Static_assert(_Alignof(struct c_extra_packed) == 1, "");
_Static_assert(sizeof(struct c_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct c_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct c_extra_size) == 6, "");
_Static_assert(_Alignof(struct c_extra_size) == 1, "");
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(d) == 8, "");
_Static_assert(_Alignof(d) == 4, "");
_Static_assert(sizeof(struct d_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct d_extra_alignment) == 4, "");
_Static_assert(sizeof(struct d_extra_packed) == 8, "");
_Static_assert(_Alignof(struct d_extra_packed) == 1, "");
_Static_assert(sizeof(struct d_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct d_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct d_extra_size) == 10, "");
_Static_assert(_Alignof(struct d_extra_size) == 1, "");
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(e) == 4, "");
_Static_assert(_Alignof(e) == 2, "");
_Static_assert(sizeof(struct e_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct e_extra_alignment) == 2, "");
_Static_assert(sizeof(struct e_extra_packed) == 4, "");
_Static_assert(_Alignof(struct e_extra_packed) == 1, "");
_Static_assert(sizeof(struct e_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct e_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct e_extra_size) == 6, "");
_Static_assert(_Alignof(struct e_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(f) == 8, "");
_Static_assert(_Alignof(f) == 2, "");
_Static_assert(sizeof(struct f_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct f_extra_alignment) == 2, "");
_Static_assert(sizeof(struct f_extra_packed) == 8, "");
_Static_assert(_Alignof(struct f_extra_packed) == 1, "");
_Static_assert(sizeof(struct f_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct f_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct f_extra_size) == 10, "");
_Static_assert(_Alignof(struct f_extra_size) == 1, "");
_Static_assert(sizeof(F) == 2, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 2, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 4, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
// MAPPING|SIX|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(SIX)
_Static_assert(sizeof(a) == 2, "");
_Static_assert(_Alignof(a) == 8, "");
_Static_assert(sizeof(struct a_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct a_extra_alignment) == 8, "");
_Static_assert(sizeof(struct a_extra_packed) == 2, "");
_Static_assert(_Alignof(struct a_extra_packed) == 1, "");
_Static_assert(sizeof(struct a_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct a_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct a_extra_size) == 4, "");
_Static_assert(_Alignof(struct a_extra_size) == 1, "");
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(b) == 2, "");
_Static_assert(_Alignof(b) == 4, "");
_Static_assert(sizeof(struct b_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct b_extra_alignment) == 4, "");
_Static_assert(sizeof(struct b_extra_packed) == 2, "");
_Static_assert(_Alignof(struct b_extra_packed) == 1, "");
_Static_assert(sizeof(struct b_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct b_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct b_extra_size) == 4, "");
_Static_assert(_Alignof(struct b_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(c) == 4, "");
_Static_assert(_Alignof(c) == 8, "");
_Static_assert(sizeof(struct c_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct c_extra_alignment) == 8, "");
_Static_assert(sizeof(struct c_extra_packed) == 4, "");
_Static_assert(_Alignof(struct c_extra_packed) == 1, "");
_Static_assert(sizeof(struct c_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct c_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct c_extra_size) == 6, "");
_Static_assert(_Alignof(struct c_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(d) == 8, "");
_Static_assert(_Alignof(d) == 4, "");
_Static_assert(sizeof(struct d_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct d_extra_alignment) == 4, "");
_Static_assert(sizeof(struct d_extra_packed) == 8, "");
_Static_assert(_Alignof(struct d_extra_packed) == 1, "");
_Static_assert(sizeof(struct d_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct d_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct d_extra_size) == 10, "");
_Static_assert(_Alignof(struct d_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(e) == 4, "");
_Static_assert(_Alignof(e) == 2, "");
_Static_assert(sizeof(struct e_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct e_extra_alignment) == 2, "");
_Static_assert(sizeof(struct e_extra_packed) == 4, "");
_Static_assert(_Alignof(struct e_extra_packed) == 1, "");
_Static_assert(sizeof(struct e_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct e_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct e_extra_size) == 6, "");
_Static_assert(_Alignof(struct e_extra_size) == 1, "");
_Static_assert(sizeof(E) == 4, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 6, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(f) == 8, "");
_Static_assert(_Alignof(f) == 2, "");
_Static_assert(sizeof(struct f_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct f_extra_alignment) == 2, "");
_Static_assert(sizeof(struct f_extra_packed) == 8, "");
_Static_assert(_Alignof(struct f_extra_packed) == 1, "");
_Static_assert(sizeof(struct f_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct f_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct f_extra_size) == 10, "");
_Static_assert(_Alignof(struct f_extra_size) == 1, "");
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
// MAPPING|SEVEN|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SEVEN)
_Static_assert(sizeof(a) == 2, "");
_Static_assert(_Alignof(a) == 8, "");
_Static_assert(sizeof(struct a_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct a_extra_alignment) == 8, "");
_Static_assert(sizeof(struct a_extra_packed) == 2, "");
_Static_assert(_Alignof(struct a_extra_packed) == 1, "");
_Static_assert(sizeof(struct a_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct a_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct a_extra_size) == 4, "");
_Static_assert(_Alignof(struct a_extra_size) == 1, "");
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(b) == 2, "");
_Static_assert(_Alignof(b) == 4, "");
_Static_assert(sizeof(struct b_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct b_extra_alignment) == 4, "");
_Static_assert(sizeof(struct b_extra_packed) == 2, "");
_Static_assert(_Alignof(struct b_extra_packed) == 1, "");
_Static_assert(sizeof(struct b_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct b_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct b_extra_size) == 4, "");
_Static_assert(_Alignof(struct b_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(c) == 2, "");
_Static_assert(_Alignof(c) == 8, "");
_Static_assert(sizeof(struct c_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct c_extra_alignment) == 8, "");
_Static_assert(sizeof(struct c_extra_packed) == 2, "");
_Static_assert(_Alignof(struct c_extra_packed) == 1, "");
_Static_assert(sizeof(struct c_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct c_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct c_extra_size) == 4, "");
_Static_assert(_Alignof(struct c_extra_size) == 1, "");
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(d) == 8, "");
_Static_assert(_Alignof(d) == 4, "");
_Static_assert(sizeof(struct d_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct d_extra_alignment) == 4, "");
_Static_assert(sizeof(struct d_extra_packed) == 8, "");
_Static_assert(_Alignof(struct d_extra_packed) == 1, "");
_Static_assert(sizeof(struct d_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct d_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct d_extra_size) == 10, "");
_Static_assert(_Alignof(struct d_extra_size) == 1, "");
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(e) == 2, "");
_Static_assert(_Alignof(e) == 2, "");
_Static_assert(sizeof(struct e_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct e_extra_alignment) == 2, "");
_Static_assert(sizeof(struct e_extra_packed) == 2, "");
_Static_assert(_Alignof(struct e_extra_packed) == 1, "");
_Static_assert(sizeof(struct e_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct e_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct e_extra_size) == 4, "");
_Static_assert(_Alignof(struct e_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(f) == 8, "");
_Static_assert(_Alignof(f) == 2, "");
_Static_assert(sizeof(struct f_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct f_extra_alignment) == 2, "");
_Static_assert(sizeof(struct f_extra_packed) == 8, "");
_Static_assert(_Alignof(struct f_extra_packed) == 1, "");
_Static_assert(sizeof(struct f_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct f_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct f_extra_size) == 10, "");
_Static_assert(_Alignof(struct f_extra_size) == 1, "");
_Static_assert(sizeof(F) == 2, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 2, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 4, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0053_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
typedef int A[];
#else
typedef int A[0];
#endif
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-windows-msvc:Msvc|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-windows-msvc:Msvc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|x86-i686-uefi-msvc:Msvc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-baseline-windows-msvc:Msvc|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") I686UnknownWindows|Some("x86-i686-uefi-msvc") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#ifdef ONE
_Static_assert(sizeof(A) == 0, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 0, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 2, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|TWO|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 0, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 0, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 2, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|THREE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 0, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 0, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 2, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0067_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
int x;
long y;
} __attribute__((packed)) A1;
A1 var1;
struct A1_extra_alignment {
char a;
A1 b;
};
struct A1_extra_alignment var2;
#pragma pack(1)
struct A1_extra_packed {
A1 a;
};
#pragma pack()
struct A1_extra_required_alignment {
char a;
struct A1_extra_packed b;
};
struct A1_extra_required_alignment var3;
struct A1_extra_size {
char a[sizeof(A1)+1];
char b;
};
struct A1_extra_size var4;
typedef struct {
int x __attribute__((packed));
long y __attribute__((packed));
} A2;
A2 var5;
struct A2_extra_alignment {
char a;
A2 b;
};
struct A2_extra_alignment var6;
#pragma pack(1)
struct A2_extra_packed {
A2 a;
};
#pragma pack()
struct A2_extra_required_alignment {
char a;
struct A2_extra_packed b;
};
struct A2_extra_required_alignment var7;
struct A2_extra_size {
char a[sizeof(A2)+1];
char b;
};
struct A2_extra_size var8;
typedef union {
int x;
long y;
} __attribute__((packed)) B1;
B1 var9;
struct B1_extra_alignment {
char a;
B1 b;
};
struct B1_extra_alignment var10;
#pragma pack(1)
struct B1_extra_packed {
B1 a;
};
#pragma pack()
struct B1_extra_required_alignment {
char a;
struct B1_extra_packed b;
};
struct B1_extra_required_alignment var11;
struct B1_extra_size {
char a[sizeof(B1)+1];
char b;
};
struct B1_extra_size var12;
typedef union {
int x __attribute__((packed));
long y __attribute__((packed));
} B2;
B2 var13;
struct B2_extra_alignment {
char a;
B2 b;
};
struct B2_extra_alignment var14;
#pragma pack(1)
struct B2_extra_packed {
B2 a;
};
#pragma pack()
struct B2_extra_required_alignment {
char a;
struct B2_extra_packed b;
};
struct B2_extra_required_alignment var15;
struct B2_extra_size {
char a[sizeof(B2)+1];
char b;
};
struct B2_extra_size var16;
typedef struct {
int x:1;
long y;
} __attribute__((packed)) C1;
C1 var17;
struct C1_extra_alignment {
char a;
C1 b;
};
struct C1_extra_alignment var18;
#pragma pack(1)
struct C1_extra_packed {
C1 a;
};
#pragma pack()
struct C1_extra_required_alignment {
char a;
struct C1_extra_packed b;
};
struct C1_extra_required_alignment var19;
struct C1_extra_size {
char a[sizeof(C1)+1];
char b;
};
struct C1_extra_size var20;
typedef struct {
int x:1 __attribute__((packed));
long y __attribute__((packed));
} C2;
C2 var21;
struct C2_extra_alignment {
char a;
C2 b;
};
struct C2_extra_alignment var22;
#pragma pack(1)
struct C2_extra_packed {
C2 a;
};
#pragma pack()
struct C2_extra_required_alignment {
char a;
struct C2_extra_packed b;
};
struct C2_extra_required_alignment var23;
struct C2_extra_size {
char a[sizeof(C2)+1];
char b;
};
struct C2_extra_size var24;
typedef union {
int x:1;
long y;
} __attribute__((packed)) D1;
D1 var25;
struct D1_extra_alignment {
char a;
D1 b;
};
struct D1_extra_alignment var26;
#pragma pack(1)
struct D1_extra_packed {
D1 a;
};
#pragma pack()
struct D1_extra_required_alignment {
char a;
struct D1_extra_packed b;
};
struct D1_extra_required_alignment var27;
struct D1_extra_size {
char a[sizeof(D1)+1];
char b;
};
struct D1_extra_size var28;
typedef union {
int x:1 __attribute__((packed));
long y __attribute__((packed));
} D2;
D2 var29;
struct D2_extra_alignment {
char a;
D2 b;
};
struct D2_extra_alignment var30;
#pragma pack(1)
struct D2_extra_packed {
D2 a;
};
#pragma pack()
struct D2_extra_required_alignment {
char a;
struct D2_extra_packed b;
};
struct D2_extra_required_alignment var31;
struct D2_extra_size {
char a[sizeof(D2)+1];
char b;
};
struct D2_extra_size var32;
typedef struct {
int:0;
long y;
} __attribute__((packed)) E1;
E1 var33;
struct E1_extra_alignment {
char a;
E1 b;
};
struct E1_extra_alignment var34;
#pragma pack(1)
struct E1_extra_packed {
E1 a;
};
#pragma pack()
struct E1_extra_required_alignment {
char a;
struct E1_extra_packed b;
};
struct E1_extra_required_alignment var35;
struct E1_extra_size {
char a[sizeof(E1)+1];
char b;
};
struct E1_extra_size var36;
typedef struct {
int:0 __attribute__((packed));
long y __attribute__((packed));
} E2;
E2 var37;
struct E2_extra_alignment {
char a;
E2 b;
};
struct E2_extra_alignment var38;
#pragma pack(1)
struct E2_extra_packed {
E2 a;
};
#pragma pack()
struct E2_extra_required_alignment {
char a;
struct E2_extra_packed b;
};
struct E2_extra_required_alignment var39;
struct E2_extra_size {
char a[sizeof(E2)+1];
char b;
};
struct E2_extra_size var40;
typedef union {
int:0;
long y;
} __attribute__((packed)) F1;
F1 var41;
struct F1_extra_alignment {
char a;
F1 b;
};
struct F1_extra_alignment var42;
#pragma pack(1)
struct F1_extra_packed {
F1 a;
};
#pragma pack()
struct F1_extra_required_alignment {
char a;
struct F1_extra_packed b;
};
struct F1_extra_required_alignment var43;
struct F1_extra_size {
char a[sizeof(F1)+1];
char b;
};
struct F1_extra_size var44;
typedef union {
int:0 __attribute__((packed));
long y __attribute__((packed));
} F2;
F2 var45;
struct F2_extra_alignment {
char a;
F2 b;
};
struct F2_extra_alignment var46;
#pragma pack(1)
struct F2_extra_packed {
F2 a;
};
#pragma pack()
struct F2_extra_required_alignment {
char a;
struct F2_extra_packed b;
};
struct F2_extra_required_alignment var47;
struct F2_extra_size {
char a[sizeof(F2)+1];
char b;
};
struct F2_extra_size var48;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A1) == 12, "");
_Static_assert(_Alignof(A1) == 1, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 13, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 14, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A1,y) == 32, "");
#endif
_Static_assert(sizeof(A2) == 12, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 13, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 14, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,y) == 32, "");
#endif
_Static_assert(sizeof(B1) == 8, "");
_Static_assert(_Alignof(B1) == 1, "");
_Static_assert(sizeof(struct B1_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B1_extra_packed) == 1, "");
_Static_assert(sizeof(struct B1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_size) == 10, "");
_Static_assert(_Alignof(struct B1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B1,y) == 0, "");
#endif
_Static_assert(sizeof(B2) == 8, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,y) == 0, "");
#endif
_Static_assert(sizeof(C1) == 9, "");
_Static_assert(_Alignof(C1) == 1, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_packed) == 9, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 11, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C1,y) == 8, "");
#endif
_Static_assert(sizeof(C2) == 9, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 9, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 11, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,y) == 8, "");
#endif
_Static_assert(sizeof(D1) == 8, "");
_Static_assert(_Alignof(D1) == 1, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 10, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D1,y) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,y) == 0, "");
#endif
_Static_assert(sizeof(E1) == 8, "");
_Static_assert(_Alignof(E1) == 1, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 10, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E1,y) == 0, "");
#endif
_Static_assert(sizeof(E2) == 8, "");
_Static_assert(_Alignof(E2) == 1, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 10, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E2,y) == 0, "");
#endif
_Static_assert(sizeof(F1) == 8, "");
_Static_assert(_Alignof(F1) == 1, "");
_Static_assert(sizeof(struct F1_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct F1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F1_extra_packed) == 1, "");
_Static_assert(sizeof(struct F1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_size) == 10, "");
_Static_assert(_Alignof(struct F1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F1,y) == 0, "");
#endif
_Static_assert(sizeof(F2) == 8, "");
_Static_assert(_Alignof(F2) == 1, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 10, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,y) == 0, "");
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None
#elif defined(TWO)
_Static_assert(sizeof(A1) == 12, "");
_Static_assert(_Alignof(A1) == 1, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 13, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 14, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A1,y) == 32, "");
#endif
_Static_assert(sizeof(A2) == 12, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 13, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 14, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,y) == 32, "");
#endif
_Static_assert(sizeof(B1) == 8, "");
_Static_assert(_Alignof(B1) == 1, "");
_Static_assert(sizeof(struct B1_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B1_extra_packed) == 1, "");
_Static_assert(sizeof(struct B1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_size) == 10, "");
_Static_assert(_Alignof(struct B1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B1,y) == 0, "");
#endif
_Static_assert(sizeof(B2) == 8, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,y) == 0, "");
#endif
_Static_assert(sizeof(C1) == 9, "");
_Static_assert(_Alignof(C1) == 1, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_packed) == 9, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 11, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C1,y) == 8, "");
#endif
_Static_assert(sizeof(C2) == 9, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 9, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 11, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,y) == 8, "");
#endif
_Static_assert(sizeof(D1) == 8, "");
_Static_assert(_Alignof(D1) == 1, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 10, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D1,y) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,y) == 0, "");
#endif
_Static_assert(sizeof(E1) == 8, "");
_Static_assert(_Alignof(E1) == 4, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 4, "");
_Static_assert(sizeof(struct E1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 10, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E1,y) == 0, "");
#endif
_Static_assert(sizeof(E2) == 8, "");
_Static_assert(_Alignof(E2) == 4, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct E2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 10, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E2,y) == 0, "");
#endif
_Static_assert(sizeof(F1) == 8, "");
_Static_assert(_Alignof(F1) == 4, "");
_Static_assert(sizeof(struct F1_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct F1_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F1_extra_packed) == 1, "");
_Static_assert(sizeof(struct F1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_size) == 10, "");
_Static_assert(_Alignof(struct F1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F1,y) == 0, "");
#endif
_Static_assert(sizeof(F2) == 8, "");
_Static_assert(_Alignof(F2) == 4, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 10, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,y) == 0, "");
#endif
// MAPPING|THREE|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A1) == 8, "");
_Static_assert(_Alignof(A1) == 1, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 10, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A1,y) == 32, "");
#endif
_Static_assert(sizeof(A2) == 8, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 10, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,y) == 32, "");
#endif
_Static_assert(sizeof(B1) == 4, "");
_Static_assert(_Alignof(B1) == 1, "");
_Static_assert(sizeof(struct B1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B1_extra_packed) == 1, "");
_Static_assert(sizeof(struct B1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_size) == 6, "");
_Static_assert(_Alignof(struct B1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B1,y) == 0, "");
#endif
_Static_assert(sizeof(B2) == 4, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 6, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,y) == 0, "");
#endif
_Static_assert(sizeof(C1) == 5, "");
_Static_assert(_Alignof(C1) == 1, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_packed) == 5, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 7, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C1,y) == 8, "");
#endif
_Static_assert(sizeof(C2) == 5, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 5, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 7, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,y) == 8, "");
#endif
_Static_assert(sizeof(D1) == 4, "");
_Static_assert(_Alignof(D1) == 1, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 6, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D1,y) == 0, "");
#endif
_Static_assert(sizeof(D2) == 4, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 6, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,y) == 0, "");
#endif
_Static_assert(sizeof(E1) == 4, "");
_Static_assert(_Alignof(E1) == 4, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 4, "");
_Static_assert(sizeof(struct E1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 6, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E1,y) == 0, "");
#endif
_Static_assert(sizeof(E2) == 4, "");
_Static_assert(_Alignof(E2) == 4, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct E2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 6, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E2,y) == 0, "");
#endif
_Static_assert(sizeof(F1) == 4, "");
_Static_assert(_Alignof(F1) == 4, "");
_Static_assert(sizeof(struct F1_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct F1_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F1_extra_packed) == 1, "");
_Static_assert(sizeof(struct F1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_size) == 6, "");
_Static_assert(_Alignof(struct F1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F1,y) == 0, "");
#endif
_Static_assert(sizeof(F2) == 4, "");
_Static_assert(_Alignof(F2) == 4, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 6, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,y) == 0, "");
#endif
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A1) == 6, "");
_Static_assert(_Alignof(A1) == 1, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 8, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A1,y) == 16, "");
#endif
_Static_assert(sizeof(A2) == 6, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 8, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,y) == 16, "");
#endif
_Static_assert(sizeof(B1) == 4, "");
_Static_assert(_Alignof(B1) == 1, "");
_Static_assert(sizeof(struct B1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B1_extra_packed) == 1, "");
_Static_assert(sizeof(struct B1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_size) == 6, "");
_Static_assert(_Alignof(struct B1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B1,y) == 0, "");
#endif
_Static_assert(sizeof(B2) == 4, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 6, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,y) == 0, "");
#endif
_Static_assert(sizeof(C1) == 5, "");
_Static_assert(_Alignof(C1) == 1, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_packed) == 5, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 7, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C1,y) == 8, "");
#endif
_Static_assert(sizeof(C2) == 5, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 5, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 7, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,y) == 8, "");
#endif
_Static_assert(sizeof(D1) == 4, "");
_Static_assert(_Alignof(D1) == 1, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 6, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D1,y) == 0, "");
#endif
_Static_assert(sizeof(D2) == 4, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 6, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,y) == 0, "");
#endif
_Static_assert(sizeof(E1) == 4, "");
_Static_assert(_Alignof(E1) == 1, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 6, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E1,y) == 0, "");
#endif
_Static_assert(sizeof(E2) == 4, "");
_Static_assert(_Alignof(E2) == 1, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 6, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E2,y) == 0, "");
#endif
_Static_assert(sizeof(F1) == 4, "");
_Static_assert(_Alignof(F1) == 1, "");
_Static_assert(sizeof(struct F1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct F1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F1_extra_packed) == 1, "");
_Static_assert(sizeof(struct F1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_size) == 6, "");
_Static_assert(_Alignof(struct F1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F1,y) == 0, "");
#endif
_Static_assert(sizeof(F2) == 4, "");
_Static_assert(_Alignof(F2) == 1, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 6, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,y) == 0, "");
#endif
// MAPPING|FIVE|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-linux-gnux32:Gcc|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32")
#elif defined(FIVE)
_Static_assert(sizeof(A1) == 8, "");
_Static_assert(_Alignof(A1) == 1, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 10, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A1,y) == 32, "");
#endif
_Static_assert(sizeof(A2) == 8, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 10, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,y) == 32, "");
#endif
_Static_assert(sizeof(B1) == 4, "");
_Static_assert(_Alignof(B1) == 1, "");
_Static_assert(sizeof(struct B1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B1_extra_packed) == 1, "");
_Static_assert(sizeof(struct B1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_size) == 6, "");
_Static_assert(_Alignof(struct B1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B1,y) == 0, "");
#endif
_Static_assert(sizeof(B2) == 4, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 6, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,y) == 0, "");
#endif
_Static_assert(sizeof(C1) == 5, "");
_Static_assert(_Alignof(C1) == 1, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_packed) == 5, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 7, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C1,y) == 8, "");
#endif
_Static_assert(sizeof(C2) == 5, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 5, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 7, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,y) == 8, "");
#endif
_Static_assert(sizeof(D1) == 4, "");
_Static_assert(_Alignof(D1) == 1, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 6, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D1,y) == 0, "");
#endif
_Static_assert(sizeof(D2) == 4, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 6, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,y) == 0, "");
#endif
_Static_assert(sizeof(E1) == 4, "");
_Static_assert(_Alignof(E1) == 1, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 6, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E1,y) == 0, "");
#endif
_Static_assert(sizeof(E2) == 4, "");
_Static_assert(_Alignof(E2) == 1, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 6, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E2,y) == 0, "");
#endif
_Static_assert(sizeof(F1) == 4, "");
_Static_assert(_Alignof(F1) == 1, "");
_Static_assert(sizeof(struct F1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct F1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F1_extra_packed) == 1, "");
_Static_assert(sizeof(struct F1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_size) == 6, "");
_Static_assert(_Alignof(struct F1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F1,y) == 0, "");
#endif
_Static_assert(sizeof(F2) == 4, "");
_Static_assert(_Alignof(F2) == 1, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 6, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,y) == 0, "");
#endif
// MAPPING|SIX|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(SIX)
_Static_assert(sizeof(A1) == 8, "");
_Static_assert(_Alignof(A1) == 1, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 10, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A1,y) == 32, "");
#endif
_Static_assert(sizeof(A2) == 8, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 10, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,y) == 32, "");
#endif
_Static_assert(sizeof(B1) == 4, "");
_Static_assert(_Alignof(B1) == 1, "");
_Static_assert(sizeof(struct B1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B1_extra_packed) == 1, "");
_Static_assert(sizeof(struct B1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_size) == 6, "");
_Static_assert(_Alignof(struct B1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B1,y) == 0, "");
#endif
_Static_assert(sizeof(B2) == 4, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 6, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,y) == 0, "");
#endif
_Static_assert(sizeof(C1) == 8, "");
_Static_assert(_Alignof(C1) == 1, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 10, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C1,y) == 32, "");
#endif
_Static_assert(sizeof(C2) == 8, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 10, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,y) == 32, "");
#endif
_Static_assert(sizeof(D1) == 4, "");
_Static_assert(_Alignof(D1) == 1, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 6, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D1,y) == 0, "");
#endif
_Static_assert(sizeof(D2) == 4, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 6, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,y) == 0, "");
#endif
_Static_assert(sizeof(E1) == 4, "");
_Static_assert(_Alignof(E1) == 1, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 6, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E1,y) == 0, "");
#endif
_Static_assert(sizeof(E2) == 4, "");
_Static_assert(_Alignof(E2) == 1, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 6, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E2,y) == 0, "");
#endif
_Static_assert(sizeof(F1) == 4, "");
_Static_assert(_Alignof(F1) == 1, "");
_Static_assert(sizeof(struct F1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct F1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F1_extra_packed) == 1, "");
_Static_assert(sizeof(struct F1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_size) == 6, "");
_Static_assert(_Alignof(struct F1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F1,y) == 0, "");
#endif
_Static_assert(sizeof(F2) == 4, "");
_Static_assert(_Alignof(F2) == 1, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 6, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,y) == 0, "");
#endif
// MAPPING|SEVEN|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SEVEN)
_Static_assert(sizeof(A1) == 6, "");
_Static_assert(_Alignof(A1) == 1, "");
_Static_assert(sizeof(struct A1_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A1_extra_packed) == 1, "");
_Static_assert(sizeof(struct A1_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A1_extra_size) == 8, "");
_Static_assert(_Alignof(struct A1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A1,y) == 16, "");
#endif
_Static_assert(sizeof(A2) == 6, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 8, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,y) == 16, "");
#endif
_Static_assert(sizeof(B1) == 4, "");
_Static_assert(_Alignof(B1) == 1, "");
_Static_assert(sizeof(struct B1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B1_extra_packed) == 1, "");
_Static_assert(sizeof(struct B1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B1_extra_size) == 6, "");
_Static_assert(_Alignof(struct B1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B1,y) == 0, "");
#endif
_Static_assert(sizeof(B2) == 4, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 6, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,y) == 0, "");
#endif
_Static_assert(sizeof(C1) == 5, "");
_Static_assert(_Alignof(C1) == 1, "");
_Static_assert(sizeof(struct C1_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_packed) == 5, "");
_Static_assert(_Alignof(struct C1_extra_packed) == 1, "");
_Static_assert(sizeof(struct C1_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C1_extra_size) == 7, "");
_Static_assert(_Alignof(struct C1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C1,y) == 8, "");
#endif
_Static_assert(sizeof(C2) == 5, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 5, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 7, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,y) == 8, "");
#endif
_Static_assert(sizeof(D1) == 4, "");
_Static_assert(_Alignof(D1) == 1, "");
_Static_assert(sizeof(struct D1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D1_extra_packed) == 1, "");
_Static_assert(sizeof(struct D1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D1_extra_size) == 6, "");
_Static_assert(_Alignof(struct D1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D1,y) == 0, "");
#endif
_Static_assert(sizeof(D2) == 4, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 6, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,y) == 0, "");
#endif
_Static_assert(sizeof(E1) == 4, "");
_Static_assert(_Alignof(E1) == 1, "");
_Static_assert(sizeof(struct E1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct E1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E1_extra_packed) == 1, "");
_Static_assert(sizeof(struct E1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E1_extra_size) == 6, "");
_Static_assert(_Alignof(struct E1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E1,y) == 0, "");
#endif
_Static_assert(sizeof(E2) == 4, "");
_Static_assert(_Alignof(E2) == 1, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 6, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E2,y) == 0, "");
#endif
_Static_assert(sizeof(F1) == 4, "");
_Static_assert(_Alignof(F1) == 1, "");
_Static_assert(sizeof(struct F1_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct F1_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F1_extra_packed) == 1, "");
_Static_assert(sizeof(struct F1_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F1_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F1_extra_size) == 6, "");
_Static_assert(_Alignof(struct F1_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F1,y) == 0, "");
#endif
_Static_assert(sizeof(F2) == 4, "");
_Static_assert(_Alignof(F2) == 1, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 6, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,y) == 0, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0069_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
long long a;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
A a;
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
long long a:1;
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
B a;
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
typedef struct {
char a:1;
long long:0;
} C;
C var9;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
C a;
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
typedef struct {
long long:0;
} D;
D var13;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var14;
#pragma pack(1)
struct D_extra_packed {
D a;
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var15;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var16;
typedef struct {
char c;
long long:0;
} E;
E var17;
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var18;
#pragma pack(1)
struct E_extra_packed {
E a;
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var19;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var20;
typedef struct {
char c;
int:0;
long long:0;
} F;
F var21;
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var22;
#pragma pack(1)
struct F_extra_packed {
F a;
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var23;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var24;
typedef struct {
int a:1 __attribute__((packed));
} G;
G var25;
struct G_extra_alignment {
char a;
G b;
};
struct G_extra_alignment var26;
#pragma pack(1)
struct G_extra_packed {
G a;
};
#pragma pack()
struct G_extra_required_alignment {
char a;
struct G_extra_packed b;
};
struct G_extra_required_alignment var27;
struct G_extra_size {
char a[sizeof(G)+1];
char b;
};
struct G_extra_size var28;
typedef struct {
int a:1 __attribute__((aligned(16))) __attribute__((packed));
} H;
H var29;
struct H_extra_alignment {
char a;
H b;
};
struct H_extra_alignment var30;
#pragma pack(1)
struct H_extra_packed {
H a;
};
#pragma pack()
struct H_extra_required_alignment {
char a;
struct H_extra_packed b;
};
struct H_extra_required_alignment var31;
struct H_extra_size {
char a[sizeof(H)+1];
char b;
};
struct H_extra_size var32;
typedef union {
long long a;
} A2;
A2 var33;
struct A2_extra_alignment {
char a;
A2 b;
};
struct A2_extra_alignment var34;
#pragma pack(1)
struct A2_extra_packed {
A2 a;
};
#pragma pack()
struct A2_extra_required_alignment {
char a;
struct A2_extra_packed b;
};
struct A2_extra_required_alignment var35;
struct A2_extra_size {
char a[sizeof(A2)+1];
char b;
};
struct A2_extra_size var36;
typedef union {
long long a:1;
} B2;
B2 var37;
struct B2_extra_alignment {
char a;
B2 b;
};
struct B2_extra_alignment var38;
#pragma pack(1)
struct B2_extra_packed {
B2 a;
};
#pragma pack()
struct B2_extra_required_alignment {
char a;
struct B2_extra_packed b;
};
struct B2_extra_required_alignment var39;
struct B2_extra_size {
char a[sizeof(B2)+1];
char b;
};
struct B2_extra_size var40;
typedef union {
char a:1;
long long:0;
} C2;
C2 var41;
struct C2_extra_alignment {
char a;
C2 b;
};
struct C2_extra_alignment var42;
#pragma pack(1)
struct C2_extra_packed {
C2 a;
};
#pragma pack()
struct C2_extra_required_alignment {
char a;
struct C2_extra_packed b;
};
struct C2_extra_required_alignment var43;
struct C2_extra_size {
char a[sizeof(C2)+1];
char b;
};
struct C2_extra_size var44;
typedef union {
long long:0;
} D2;
D2 var45;
struct D2_extra_alignment {
char a;
D2 b;
};
struct D2_extra_alignment var46;
#pragma pack(1)
struct D2_extra_packed {
D2 a;
};
#pragma pack()
struct D2_extra_required_alignment {
char a;
struct D2_extra_packed b;
};
struct D2_extra_required_alignment var47;
struct D2_extra_size {
char a[sizeof(D2)+1];
char b;
};
struct D2_extra_size var48;
typedef union {
char c;
long long:0;
} E2;
E2 var49;
struct E2_extra_alignment {
char a;
E2 b;
};
struct E2_extra_alignment var50;
#pragma pack(1)
struct E2_extra_packed {
E2 a;
};
#pragma pack()
struct E2_extra_required_alignment {
char a;
struct E2_extra_packed b;
};
struct E2_extra_required_alignment var51;
struct E2_extra_size {
char a[sizeof(E2)+1];
char b;
};
struct E2_extra_size var52;
typedef union {
char c;
int:0;
long long:0;
} F2;
F2 var53;
struct F2_extra_alignment {
char a;
F2 b;
};
struct F2_extra_alignment var54;
#pragma pack(1)
struct F2_extra_packed {
F2 a;
};
#pragma pack()
struct F2_extra_required_alignment {
char a;
struct F2_extra_packed b;
};
struct F2_extra_required_alignment var55;
struct F2_extra_size {
char a[sizeof(F2)+1];
char b;
};
struct F2_extra_size var56;
typedef union {
int a:1 __attribute__((packed));
} G2;
G2 var57;
struct G2_extra_alignment {
char a;
G2 b;
};
struct G2_extra_alignment var58;
#pragma pack(1)
struct G2_extra_packed {
G2 a;
};
#pragma pack()
struct G2_extra_required_alignment {
char a;
struct G2_extra_packed b;
};
struct G2_extra_required_alignment var59;
struct G2_extra_size {
char a[sizeof(G2)+1];
char b;
};
struct G2_extra_size var60;
typedef union {
int a:1 __attribute__((aligned(16))) __attribute__((packed));
} H2;
H2 var61;
struct H2_extra_alignment {
char a;
H2 b;
};
struct H2_extra_alignment var62;
#pragma pack(1)
struct H2_extra_packed {
H2 a;
};
#pragma pack()
struct H2_extra_required_alignment {
char a;
struct H2_extra_packed b;
};
struct H2_extra_required_alignment var63;
struct H2_extra_size {
char a[sizeof(H2)+1];
char b;
};
struct H2_extra_size var64;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G) == 1, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 3, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 16, "");
_Static_assert(_Alignof(H) == 16, "");
_Static_assert(sizeof(struct H_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 18, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 8, "");
_Static_assert(_Alignof(A2) == 8, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 10, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B2) == 8, "");
_Static_assert(_Alignof(B2) == 8, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D2) == 0, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 2, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 1, "");
_Static_assert(_Alignof(E2) == 1, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 3, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F2) == 1, "");
_Static_assert(_Alignof(F2) == 1, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 3, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G2) == 1, "");
_Static_assert(_Alignof(G2) == 1, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 3, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
_Static_assert(sizeof(H2) == 16, "");
_Static_assert(_Alignof(H2) == 16, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 18, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 8, "");
_Static_assert(sizeof(struct F_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 8, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G) == 1, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 3, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 16, "");
_Static_assert(_Alignof(H) == 16, "");
_Static_assert(sizeof(struct H_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 18, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 8, "");
_Static_assert(_Alignof(A2) == 8, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 10, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B2) == 8, "");
_Static_assert(_Alignof(B2) == 8, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 8, "");
_Static_assert(_Alignof(C2) == 8, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 10, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D2) == 0, "");
_Static_assert(_Alignof(D2) == 8, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D2_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 2, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 8, "");
_Static_assert(_Alignof(E2) == 8, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 10, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F2) == 8, "");
_Static_assert(_Alignof(F2) == 8, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct F2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 10, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G2) == 1, "");
_Static_assert(_Alignof(G2) == 1, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 3, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
_Static_assert(sizeof(H2) == 16, "");
_Static_assert(_Alignof(H2) == 16, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 18, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(THREE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 4, "");
_Static_assert(_Alignof(E) == 4, "");
_Static_assert(sizeof(struct E_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 4, "");
_Static_assert(sizeof(struct E_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 6, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F) == 4, "");
_Static_assert(_Alignof(F) == 4, "");
_Static_assert(sizeof(struct F_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 6, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G) == 1, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 3, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 16, "");
_Static_assert(_Alignof(H) == 16, "");
_Static_assert(sizeof(struct H_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 18, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 8, "");
_Static_assert(_Alignof(A2) == 4, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 10, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B2) == 1, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 4, "");
_Static_assert(_Alignof(C2) == 4, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 6, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D2) == 0, "");
_Static_assert(_Alignof(D2) == 4, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D2_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 2, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 4, "");
_Static_assert(_Alignof(E2) == 4, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct E2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 6, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F2) == 4, "");
_Static_assert(_Alignof(F2) == 4, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 6, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G2) == 1, "");
_Static_assert(_Alignof(G2) == 1, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 3, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
_Static_assert(sizeof(H2) == 16, "");
_Static_assert(_Alignof(H2) == 16, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 18, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 1, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 3, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F) == 1, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 1, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 3, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G) == 1, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 3, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 16, "");
_Static_assert(_Alignof(H) == 16, "");
_Static_assert(sizeof(struct H_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 18, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 8, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 10, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B2) == 1, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D2) == 0, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 2, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 1, "");
_Static_assert(_Alignof(E2) == 1, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 3, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F2) == 1, "");
_Static_assert(_Alignof(F2) == 1, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 3, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G2) == 1, "");
_Static_assert(_Alignof(G2) == 1, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 3, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
_Static_assert(sizeof(H2) == 16, "");
_Static_assert(_Alignof(H2) == 16, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 18, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
// MAPPING|FIVE|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 4, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 6, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F) == 4, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 6, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G) == 1, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 3, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 16, "");
_Static_assert(_Alignof(H) == 16, "");
_Static_assert(sizeof(struct H_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 18, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 8, "");
_Static_assert(_Alignof(A2) == 4, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 10, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B2) == 4, "");
_Static_assert(_Alignof(B2) == 4, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 6, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D2) == 0, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 2, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 1, "");
_Static_assert(_Alignof(E2) == 1, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 3, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F2) == 1, "");
_Static_assert(_Alignof(F2) == 1, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 3, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G2) == 1, "");
_Static_assert(_Alignof(G2) == 1, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 3, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
_Static_assert(sizeof(H2) == 16, "");
_Static_assert(_Alignof(H2) == 16, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 18, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
// MAPPING|SIX|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(SIX)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 1, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 3, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F) == 1, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 1, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 3, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G) == 4, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 4, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 6, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 4, "");
_Static_assert(_Alignof(H) == 1, "");
_Static_assert(sizeof(struct H_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_packed) == 4, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 6, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 8, "");
_Static_assert(_Alignof(A2) == 8, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 10, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B2) == 8, "");
_Static_assert(_Alignof(B2) == 8, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D2) == 0, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 2, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 1, "");
_Static_assert(_Alignof(E2) == 1, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 3, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F2) == 1, "");
_Static_assert(_Alignof(F2) == 1, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 3, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G2) == 1, "");
_Static_assert(_Alignof(G2) == 1, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 3, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
_Static_assert(sizeof(H2) == 1, "");
_Static_assert(_Alignof(H2) == 1, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 3, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
// MAPPING|SEVEN|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SEVEN)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F) == 2, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 2, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 4, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G) == 1, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 3, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 16, "");
_Static_assert(_Alignof(H) == 16, "");
_Static_assert(sizeof(struct H_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 18, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(A2) == 8, "");
_Static_assert(_Alignof(A2) == 2, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 10, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
_Static_assert(sizeof(B2) == 2, "");
_Static_assert(_Alignof(B2) == 2, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 4, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D2) == 0, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 2, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
_Static_assert(sizeof(E2) == 1, "");
_Static_assert(_Alignof(E2) == 1, "");
_Static_assert(sizeof(struct E2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E2_extra_packed) == 1, "");
_Static_assert(sizeof(struct E2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E2_extra_size) == 3, "");
_Static_assert(_Alignof(struct E2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(F2) == 1, "");
_Static_assert(_Alignof(F2) == 1, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 3, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(G2) == 1, "");
_Static_assert(_Alignof(G2) == 1, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 3, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
_Static_assert(sizeof(H2) == 16, "");
_Static_assert(_Alignof(H2) == 16, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 18, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0024_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
typedef long long unnamed_type_1[];
#else
typedef long long unnamed_type_1[0];
#endif
unnamed_type_1 var2;
struct unnamed_type_1_extra_alignment {
char a;
unnamed_type_1 b;
};
struct unnamed_type_1_extra_alignment var3;
#pragma pack(1)
struct unnamed_type_1_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_1)];
#else
unnamed_type_1 a;
#endif
};
#pragma pack()
struct unnamed_type_1_extra_required_alignment {
char a;
struct unnamed_type_1_extra_packed b;
};
struct unnamed_type_1_extra_required_alignment var4;
struct unnamed_type_1_extra_size {
char a[sizeof(unnamed_type_1)+1];
char b;
};
struct unnamed_type_1_extra_size var5;
typedef union {
unnamed_type_1 b;
} X;
X var6;
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var7;
#pragma pack(1)
struct X_extra_packed {
#ifdef MSVC
char a[sizeof(X)];
#else
X a;
#endif
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var8;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var9;
#ifdef MSVC
typedef char unnamed_type_10[];
#else
typedef char unnamed_type_10[0];
#endif
unnamed_type_10 var11;
struct unnamed_type_10_extra_alignment {
char a;
unnamed_type_10 b;
};
struct unnamed_type_10_extra_alignment var12;
#pragma pack(1)
struct unnamed_type_10_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_10)];
#else
unnamed_type_10 a;
#endif
};
#pragma pack()
struct unnamed_type_10_extra_required_alignment {
char a;
struct unnamed_type_10_extra_packed b;
};
struct unnamed_type_10_extra_required_alignment var13;
struct unnamed_type_10_extra_size {
char a[sizeof(unnamed_type_10)+1];
char b;
};
struct unnamed_type_10_extra_size var14;
typedef union {
long long:0;
unnamed_type_10 b;
} Y;
Y var15;
struct Y_extra_alignment {
char a;
Y b;
};
struct Y_extra_alignment var16;
#pragma pack(1)
struct Y_extra_packed {
#ifdef MSVC
char a[sizeof(Y)];
#else
Y a;
#endif
};
#pragma pack()
struct Y_extra_required_alignment {
char a;
struct Y_extra_packed b;
};
struct Y_extra_required_alignment var17;
struct Y_extra_size {
char a[sizeof(Y)+1];
char b;
};
struct Y_extra_size var18;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|x86-i686-windows-gnu:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I686PcWindowsGnu|Some("x86-i686-windows-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(X) == 0, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 0, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 2, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 0, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 0, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 2, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,b) == 0, "");
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(X) == 0, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 0, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 2, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 0, "");
_Static_assert(_Alignof(Y) == 8, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y_extra_packed) == 0, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 2, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,b) == 0, "");
#endif
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(THREE)
_Static_assert(sizeof(X) == 8, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 8, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 10, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 1, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,b) == 0, "");
#endif
// MAPPING|FOUR|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(FOUR)
_Static_assert(sizeof(X) == 0, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 0, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 2, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 0, "");
_Static_assert(_Alignof(Y) == 4, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Y_extra_packed) == 0, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 2, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,b) == 0, "");
#endif
// MAPPING|FIVE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(X) == 0, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 0, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 2, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 0, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 0, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 2, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,b) == 0, "");
#endif
// MAPPING|SIX|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(SIX)
_Static_assert(sizeof(X) == 0, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 0, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 2, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 0, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 0, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 2, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,b) == 0, "");
#endif
// MAPPING|SEVEN|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SEVEN)
_Static_assert(sizeof(X) == 0, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 0, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 2, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 0, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 0, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 2, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,b) == 0, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0038_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(1)
typedef struct {
#ifdef MSVC
__declspec(align(2)) char c:1;
#else
char c:1 __attribute__((aligned(2)));
#endif
} A;
A var1;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|avr-avr2-other-eabi:Gcc|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|msp430-msp430-other-eabi:Clang|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") AvrUnknownUnknown|Some("avr-avr2-other-eabi") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Msp430NoneElf|Some("msp430-msp430-other-eabi") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0021_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
#ifdef MSVC
__declspec(align(16)) int i:1;
#else
int i:1 __attribute__((aligned(16)));
#endif
} Y;
Y var1;
struct Y_extra_alignment {
char a;
Y b;
};
struct Y_extra_alignment var2;
#pragma pack(1)
struct Y_extra_packed {
#ifdef MSVC
char a[sizeof(Y)];
#else
Y a;
#endif
};
#pragma pack()
struct Y_extra_required_alignment {
char a;
struct Y_extra_packed b;
};
struct Y_extra_required_alignment var3;
struct Y_extra_size {
char a[sizeof(Y)+1];
char b;
};
struct Y_extra_size var4;
typedef struct {
char c;
Y y;
} Z;
Z var5;
struct Z_extra_alignment {
char a;
Z b;
};
struct Z_extra_alignment var6;
#pragma pack(1)
struct Z_extra_packed {
#ifdef MSVC
char a[sizeof(Z)];
#else
Z a;
#endif
};
#pragma pack()
struct Z_extra_required_alignment {
char a;
struct Z_extra_packed b;
};
struct Z_extra_required_alignment var7;
struct Z_extra_size {
char a[sizeof(Z)+1];
char b;
};
struct Z_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-windows-msvc:Msvc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|x86-i686-uefi-msvc:Msvc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") I686UnknownWindows|Some("x86-i686-uefi-msvc") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#ifdef ONE
_Static_assert(sizeof(Y) == 16, "");
_Static_assert(_Alignof(Y) == 16, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 16, "");
_Static_assert(sizeof(struct Y_extra_packed) == 16, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 18, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
_Static_assert(sizeof(Z) == 32, "");
_Static_assert(_Alignof(Z) == 16, "");
_Static_assert(sizeof(struct Z_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct Z_extra_alignment) == 16, "");
_Static_assert(sizeof(struct Z_extra_packed) == 32, "");
_Static_assert(_Alignof(struct Z_extra_packed) == 1, "");
_Static_assert(sizeof(struct Z_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct Z_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Z_extra_size) == 34, "");
_Static_assert(_Alignof(struct Z_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Z,y) == 128, "");
#endif
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc")
#elif defined(TWO)
_Static_assert(sizeof(Y) == 8, "");
_Static_assert(_Alignof(Y) == 16, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 16, "");
_Static_assert(sizeof(struct Y_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
_Static_assert(sizeof(Z) == 16, "");
_Static_assert(_Alignof(Z) == 8, "");
_Static_assert(sizeof(struct Z_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct Z_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Z_extra_packed) == 16, "");
_Static_assert(_Alignof(struct Z_extra_packed) == 1, "");
_Static_assert(sizeof(struct Z_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct Z_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Z_extra_size) == 18, "");
_Static_assert(_Alignof(struct Z_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Z,y) == 64, "");
#endif
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(Y) == 16, "");
_Static_assert(_Alignof(Y) == 16, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 16, "");
_Static_assert(sizeof(struct Y_extra_packed) == 16, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 18, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
_Static_assert(sizeof(Z) == 32, "");
_Static_assert(_Alignof(Z) == 16, "");
_Static_assert(sizeof(struct Z_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct Z_extra_alignment) == 16, "");
_Static_assert(sizeof(struct Z_extra_packed) == 32, "");
_Static_assert(_Alignof(struct Z_extra_packed) == 1, "");
_Static_assert(sizeof(struct Z_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct Z_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Z_extra_size) == 34, "");
_Static_assert(_Alignof(struct Z_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Z,y) == 128, "");
#endif
// MAPPING|FOUR|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(Y) == 16, "");
_Static_assert(_Alignof(Y) == 16, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 16, "");
_Static_assert(sizeof(struct Y_extra_packed) == 16, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 18, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
_Static_assert(sizeof(Z) == 32, "");
_Static_assert(_Alignof(Z) == 16, "");
_Static_assert(sizeof(struct Z_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct Z_extra_alignment) == 16, "");
_Static_assert(sizeof(struct Z_extra_packed) == 32, "");
_Static_assert(_Alignof(struct Z_extra_packed) == 1, "");
_Static_assert(sizeof(struct Z_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct Z_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Z_extra_size) == 34, "");
_Static_assert(_Alignof(struct Z_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Z,y) == 128, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0058_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(4)) typedef char Char;
#else
typedef char Char __attribute__((aligned(4)));
#endif
Char var1;
struct Char_extra_alignment {
char a;
Char b;
};
struct Char_extra_alignment var2;
#pragma pack(1)
struct Char_extra_packed {
#ifdef MSVC
char a[sizeof(Char)];
#else
Char a;
#endif
};
#pragma pack()
struct Char_extra_required_alignment {
char a;
struct Char_extra_packed b;
};
struct Char_extra_required_alignment var3;
struct Char_extra_size {
char a[sizeof(Char)+1];
char b;
};
struct Char_extra_size var4;
typedef struct {
char c;
Char a;
} __attribute__((packed)) A;
A var5;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var6;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var7;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var8;
typedef struct {
char c;
#ifdef MSVC
__declspec(align(4)) char a;
#else
char a __attribute__((aligned(4)));
#endif
} __attribute__((packed)) B;
B var9;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var10;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var11;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var12;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|avr-avr2-other-eabi:Gcc|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|msp430-msp430-other-eabi:Clang|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") AvrUnknownUnknown|Some("avr-avr2-other-eabi") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Msp430NoneElf|Some("msp430-msp430-other-eabi") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(Char) == 1, "");
_Static_assert(_Alignof(Char) == 4, "");
_Static_assert(sizeof(struct Char_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Char_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Char_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Char_extra_packed) == 1, "");
_Static_assert(sizeof(struct Char_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Char_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Char_extra_size) == 3, "");
_Static_assert(_Alignof(struct Char_extra_size) == 1, "");
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 8, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,a) == 32, "");
#endif
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(Char) == 1, "");
_Static_assert(_Alignof(Char) == 4, "");
_Static_assert(sizeof(struct Char_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Char_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Char_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Char_extra_packed) == 1, "");
_Static_assert(sizeof(struct Char_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Char_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Char_extra_size) == 3, "");
_Static_assert(_Alignof(struct Char_extra_size) == 1, "");
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 32, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,a) == 32, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0071_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c;
int:1;
} __attribute__((packed)) B;
B var1;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var2;
#pragma pack(1)
struct B_extra_packed {
B a;
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var3;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var4;
typedef struct {
char c;
int:1 __attribute__((aligned(8)));
} __attribute__((packed)) C;
C var5;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var6;
#pragma pack(1)
struct C_extra_packed {
C a;
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var7;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var8;
typedef struct {
char c;
int:1;
char d;
} __attribute__((packed)) D;
D var9;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var10;
#pragma pack(1)
struct D_extra_packed {
D a;
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var11;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var12;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 9, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 9, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 11, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 3, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 3, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 5, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 16, "");
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 16, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 16, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 18, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 3, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 3, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 5, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 16, "");
#endif
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 16, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 16, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 18, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 3, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 3, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 5, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 16, "");
#endif
// MAPPING|FOUR|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(FOUR)
_Static_assert(sizeof(B) == 5, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 5, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 7, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 12, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 13, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 12, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 14, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 6, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 6, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 8, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 40, "");
#endif
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(C) == 9, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 9, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 11, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(D) == 3, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 3, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 5, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 16, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0034_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef union {
int l;
char c;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
char c;
long l;
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,c) == 0, "");
#endif
_Static_assert(sizeof(B) == 16, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 18, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,l) == 64, "");
#endif
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-windows-msvc:Msvc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|x86-i686-uefi-msvc:Msvc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-baseline-windows-msvc:Msvc|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") I686UnknownWindows|Some("x86-i686-uefi-msvc") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,c) == 0, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,l) == 32, "");
#endif
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,c) == 0, "");
#endif
_Static_assert(sizeof(B) == 5, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 5, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 7, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,l) == 8, "");
#endif
// MAPPING|FOUR|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,c) == 0, "");
#endif
_Static_assert(sizeof(B) == 6, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 6, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 8, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,l) == 16, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0052_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c;
} __attribute__((aligned)) A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
A a;
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-baseline-ios-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|msp430-msp430-other-eabi:Clang|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") ArmLinuxAndroideabi|None Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7sAppleIos|Some("arm-baseline-ios-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") Msp430NoneElf|Some("msp430-msp430-other-eabi") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 16, "");
_Static_assert(_Alignof(A) == 16, "");
_Static_assert(sizeof(struct A_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 18, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|TWO|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|s390x-generic-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0019_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef enum {
F1 = 1,
} A;
A var2;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var3;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var4;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var5;
#ifdef MSVC
__declspec(align(8)) typedef enum {
#else
typedef enum {
#endif
F6 = 1,
F7 = 281470950178815,
#ifdef MSVC
} E;
#else
} __attribute__((aligned(8))) E;
#endif
E var8;
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var9;
#pragma pack(1)
struct E_extra_packed {
#ifdef MSVC
char a[sizeof(E)];
#else
E a;
#endif
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var10;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var11;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|x86-pentium4-ios-none:Clang|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") I386AppleIos|Some("x86-pentium4-ios-none") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(E) == 4, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 6, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
// MAPPING|FOUR|hexagon-generic-linux-musl:Clang|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
// MAPPING|FIVE|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|END
// repr targets I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 4, "");
_Static_assert(sizeof(struct E_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 4, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0037_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
unsigned int i:1;
#ifdef MSVC
__declspec(align(128)) long j:1;
#else
long j:1 __attribute__((aligned(128)));
#endif
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
unsigned int i:1;
int k:1;
#ifdef MSVC
__declspec(align(128)) long j:1;
#else
long j:1 __attribute__((aligned(128)));
#endif
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
typedef struct {
unsigned int i:1;
#ifdef MSVC
__declspec(align(128)) long j:1;
#else
long j:1 __attribute__((aligned(128)));
#endif
int k:1;
} C;
C var9;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
typedef struct {
#ifdef MSVC
__declspec(align(64)) unsigned int i:1;
__declspec(align(128)) long j:1;
#else
unsigned int i:1 __attribute__((aligned(64)));
long j:1 __attribute__((aligned(128)));
#endif
int k:1;
} D;
D var13;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var14;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var15;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var16;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 256, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 256, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 258, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,j) == 1024, "");
#endif
_Static_assert(sizeof(B) == 256, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 256, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 258, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,k) == 1, "");
_Static_assert(__builtin_bitoffsetof(B,j) == 1024, "");
#endif
_Static_assert(sizeof(C) == 256, "");
_Static_assert(_Alignof(C) == 128, "");
_Static_assert(sizeof(struct C_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C_extra_packed) == 256, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 258, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,j) == 1024, "");
_Static_assert(__builtin_bitoffsetof(C,k) == 1025, "");
#endif
_Static_assert(sizeof(D) == 256, "");
_Static_assert(_Alignof(D) == 128, "");
_Static_assert(sizeof(struct D_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 128, "");
_Static_assert(sizeof(struct D_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 258, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,j) == 1024, "");
_Static_assert(__builtin_bitoffsetof(D,k) == 1025, "");
#endif
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,j) == 1, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,k) == 1, "");
_Static_assert(__builtin_bitoffsetof(B,j) == 2, "");
#endif
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,j) == 1, "");
_Static_assert(__builtin_bitoffsetof(C,k) == 2, "");
#endif
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 64, "");
_Static_assert(sizeof(struct D_extra_alignment) == 128, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 64, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,j) == 1, "");
_Static_assert(__builtin_bitoffsetof(D,k) == 2, "");
#endif
// MAPPING|THREE|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-linux-gnux32:Gcc|END
// repr targets Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32")
#elif defined(THREE)
_Static_assert(sizeof(A) == 256, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 256, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 258, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,j) == 1024, "");
#endif
_Static_assert(sizeof(B) == 256, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 256, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 258, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,k) == 1, "");
_Static_assert(__builtin_bitoffsetof(B,j) == 1024, "");
#endif
_Static_assert(sizeof(C) == 256, "");
_Static_assert(_Alignof(C) == 128, "");
_Static_assert(sizeof(struct C_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C_extra_packed) == 256, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 258, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,j) == 1024, "");
_Static_assert(__builtin_bitoffsetof(C,k) == 1025, "");
#endif
_Static_assert(sizeof(D) == 256, "");
_Static_assert(_Alignof(D) == 128, "");
_Static_assert(sizeof(struct D_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 128, "");
_Static_assert(sizeof(struct D_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 258, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,j) == 1024, "");
_Static_assert(__builtin_bitoffsetof(D,k) == 1025, "");
#endif
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 256, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 256, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 258, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,j) == 1024, "");
#endif
_Static_assert(sizeof(B) == 256, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 256, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 258, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,k) == 1, "");
_Static_assert(__builtin_bitoffsetof(B,j) == 1024, "");
#endif
_Static_assert(sizeof(C) == 256, "");
_Static_assert(_Alignof(C) == 128, "");
_Static_assert(sizeof(struct C_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C_extra_packed) == 256, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 258, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,j) == 1024, "");
_Static_assert(__builtin_bitoffsetof(C,k) == 1025, "");
#endif
_Static_assert(sizeof(D) == 256, "");
_Static_assert(_Alignof(D) == 128, "");
_Static_assert(sizeof(struct D_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 128, "");
_Static_assert(sizeof(struct D_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 258, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,j) == 1024, "");
_Static_assert(__builtin_bitoffsetof(D,k) == 1025, "");
#endif
// MAPPING|FIVE|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,j) == 1, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,k) == 1, "");
_Static_assert(__builtin_bitoffsetof(B,j) == 2, "");
#endif
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,j) == 1, "");
_Static_assert(__builtin_bitoffsetof(C,k) == 2, "");
#endif
_Static_assert(sizeof(D) == 64, "");
_Static_assert(_Alignof(D) == 64, "");
_Static_assert(sizeof(struct D_extra_alignment) == 128, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 64, "");
_Static_assert(sizeof(struct D_extra_packed) == 64, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 66, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,j) == 1, "");
_Static_assert(__builtin_bitoffsetof(D,k) == 2, "");
#endif
// MAPPING|SIX|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(SIX)
_Static_assert(sizeof(A) == 128, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 128, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 130, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,j) == 1, "");
#endif
_Static_assert(sizeof(B) == 128, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 128, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 130, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,k) == 1, "");
_Static_assert(__builtin_bitoffsetof(B,j) == 2, "");
#endif
_Static_assert(sizeof(C) == 128, "");
_Static_assert(_Alignof(C) == 128, "");
_Static_assert(sizeof(struct C_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C_extra_packed) == 128, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 130, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,j) == 1, "");
_Static_assert(__builtin_bitoffsetof(C,k) == 2, "");
#endif
_Static_assert(sizeof(D) == 128, "");
_Static_assert(_Alignof(D) == 128, "");
_Static_assert(sizeof(struct D_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 128, "");
_Static_assert(sizeof(struct D_extra_packed) == 128, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 130, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,j) == 1, "");
_Static_assert(__builtin_bitoffsetof(D,k) == 2, "");
#endif
// MAPPING|SEVEN|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SEVEN)
_Static_assert(sizeof(A) == 256, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 256, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 258, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,j) == 1024, "");
#endif
_Static_assert(sizeof(B) == 256, "");
_Static_assert(_Alignof(B) == 128, "");
_Static_assert(sizeof(struct B_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 128, "");
_Static_assert(sizeof(struct B_extra_packed) == 256, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 258, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,k) == 1, "");
_Static_assert(__builtin_bitoffsetof(B,j) == 1024, "");
#endif
_Static_assert(sizeof(C) == 256, "");
_Static_assert(_Alignof(C) == 128, "");
_Static_assert(sizeof(struct C_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 128, "");
_Static_assert(sizeof(struct C_extra_packed) == 256, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 258, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,j) == 1024, "");
_Static_assert(__builtin_bitoffsetof(C,k) == 1025, "");
#endif
_Static_assert(sizeof(D) == 256, "");
_Static_assert(_Alignof(D) == 128, "");
_Static_assert(sizeof(struct D_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 128, "");
_Static_assert(sizeof(struct D_extra_packed) == 256, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 258, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,j) == 1024, "");
_Static_assert(__builtin_bitoffsetof(D,k) == 1025, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0026_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(2)
typedef struct {
#ifdef MSVC
__declspec(align(4)) char:1;
#else
char:1 __attribute__((aligned(4)));
#endif
} A;
A var1;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
#ifdef MSVC
typedef A unnamed_type_5[];
#else
typedef A unnamed_type_5[0];
#endif
unnamed_type_5 var6;
struct unnamed_type_5_extra_alignment {
char a;
unnamed_type_5 b;
};
struct unnamed_type_5_extra_alignment var7;
#pragma pack(1)
struct unnamed_type_5_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_5)];
#else
unnamed_type_5 a;
#endif
};
#pragma pack()
struct unnamed_type_5_extra_required_alignment {
char a;
struct unnamed_type_5_extra_packed b;
};
struct unnamed_type_5_extra_required_alignment var8;
struct unnamed_type_5_extra_size {
char a[sizeof(unnamed_type_5)+1];
char b;
};
struct unnamed_type_5_extra_size var9;
typedef struct {
unnamed_type_5 a;
} B;
B var10;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var11;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var12;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var13;
#ifdef MSVC
__declspec(align(2)) typedef char C;
#else
typedef char C __attribute__((aligned(2)));
#endif
C var14;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var15;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var16;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var17;
#ifdef MSVC
typedef C unnamed_type_18[];
#else
typedef C unnamed_type_18[0];
#endif
unnamed_type_18 var19;
struct unnamed_type_18_extra_alignment {
char a;
unnamed_type_18 b;
};
struct unnamed_type_18_extra_alignment var20;
#pragma pack(1)
struct unnamed_type_18_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_18)];
#else
unnamed_type_18 a;
#endif
};
#pragma pack()
struct unnamed_type_18_extra_required_alignment {
char a;
struct unnamed_type_18_extra_packed b;
};
struct unnamed_type_18_extra_required_alignment var21;
struct unnamed_type_18_extra_size {
char a[sizeof(unnamed_type_18)+1];
char b;
};
struct unnamed_type_18_extra_size var22;
typedef struct {
unnamed_type_18 a;
} D;
D var23;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var24;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var25;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var26;
#pragma pack(2)
typedef struct {
#ifdef MSVC
__declspec(align(8)) char:1;
__declspec(align(2)) char c;
#else
char:1 __attribute__((aligned(8)));
char c __attribute__((aligned(2)));
#endif
} E;
E var27;
#pragma pack()
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var28;
#pragma pack(1)
struct E_extra_packed {
#ifdef MSVC
char a[sizeof(E)];
#else
E a;
#endif
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var29;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var30;
#ifdef MSVC
typedef E unnamed_type_31[];
#else
typedef E unnamed_type_31[0];
#endif
unnamed_type_31 var32;
struct unnamed_type_31_extra_alignment {
char a;
unnamed_type_31 b;
};
struct unnamed_type_31_extra_alignment var33;
#pragma pack(1)
struct unnamed_type_31_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_31)];
#else
unnamed_type_31 a;
#endif
};
#pragma pack()
struct unnamed_type_31_extra_required_alignment {
char a;
struct unnamed_type_31_extra_packed b;
};
struct unnamed_type_31_extra_required_alignment var34;
struct unnamed_type_31_extra_size {
char a[sizeof(unnamed_type_31)+1];
char b;
};
struct unnamed_type_31_extra_size var35;
typedef struct {
unnamed_type_31 a;
} F;
F var36;
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var37;
#pragma pack(1)
struct F_extra_packed {
#ifdef MSVC
char a[sizeof(F)];
#else
F a;
#endif
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var38;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var39;
typedef struct {
#ifdef MSVC
__declspec(align(16)) char:1;
__declspec(align(8)) char c;
#else
char:1 __attribute__((aligned(16)));
char c __attribute__((aligned(8)));
#endif
} G;
G var40;
struct G_extra_alignment {
char a;
G b;
};
struct G_extra_alignment var41;
#pragma pack(1)
struct G_extra_packed {
#ifdef MSVC
char a[sizeof(G)];
#else
G a;
#endif
};
#pragma pack()
struct G_extra_required_alignment {
char a;
struct G_extra_packed b;
};
struct G_extra_required_alignment var42;
struct G_extra_size {
char a[sizeof(G)+1];
char b;
};
struct G_extra_size var43;
#ifdef MSVC
typedef G unnamed_type_44[];
#else
typedef G unnamed_type_44[0];
#endif
unnamed_type_44 var45;
struct unnamed_type_44_extra_alignment {
char a;
unnamed_type_44 b;
};
struct unnamed_type_44_extra_alignment var46;
#pragma pack(1)
struct unnamed_type_44_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_44)];
#else
unnamed_type_44 a;
#endif
};
#pragma pack()
struct unnamed_type_44_extra_required_alignment {
char a;
struct unnamed_type_44_extra_packed b;
};
struct unnamed_type_44_extra_required_alignment var47;
struct unnamed_type_44_extra_size {
char a[sizeof(unnamed_type_44)+1];
char b;
};
struct unnamed_type_44_extra_size var48;
typedef struct {
unnamed_type_44 a;
} H;
H var49;
struct H_extra_alignment {
char a;
H b;
};
struct H_extra_alignment var50;
#pragma pack(1)
struct H_extra_packed {
#ifdef MSVC
char a[sizeof(H)];
#else
H a;
#endif
};
#pragma pack()
struct H_extra_required_alignment {
char a;
struct H_extra_packed b;
};
struct H_extra_required_alignment var51;
struct H_extra_size {
char a[sizeof(H)+1];
char b;
};
struct H_extra_size var52;
#ifdef MSVC
typedef char unnamed_type_53[];
#else
typedef char unnamed_type_53[0];
#endif
unnamed_type_53 var54;
struct unnamed_type_53_extra_alignment {
char a;
unnamed_type_53 b;
};
struct unnamed_type_53_extra_alignment var55;
#pragma pack(1)
struct unnamed_type_53_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_53)];
#else
unnamed_type_53 a;
#endif
};
#pragma pack()
struct unnamed_type_53_extra_required_alignment {
char a;
struct unnamed_type_53_extra_packed b;
};
struct unnamed_type_53_extra_required_alignment var56;
struct unnamed_type_53_extra_size {
char a[sizeof(unnamed_type_53)+1];
char b;
};
struct unnamed_type_53_extra_size var57;
typedef struct {
unnamed_type_53 a;
} I;
I var58;
struct I_extra_alignment {
char a;
I b;
};
struct I_extra_alignment var59;
#pragma pack(1)
struct I_extra_packed {
#ifdef MSVC
char a[sizeof(I)];
#else
I a;
#endif
};
#pragma pack()
struct I_extra_required_alignment {
char a;
struct I_extra_packed b;
};
struct I_extra_required_alignment var60;
struct I_extra_size {
char a[sizeof(I)+1];
char b;
};
struct I_extra_size var61;
#ifdef MSVC
typedef char unnamed_type_62[];
#else
typedef char unnamed_type_62[0];
#endif
unnamed_type_62 var63;
struct unnamed_type_62_extra_alignment {
char a;
unnamed_type_62 b;
};
struct unnamed_type_62_extra_alignment var64;
#pragma pack(1)
struct unnamed_type_62_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_62)];
#else
unnamed_type_62 a;
#endif
};
#pragma pack()
struct unnamed_type_62_extra_required_alignment {
char a;
struct unnamed_type_62_extra_packed b;
};
struct unnamed_type_62_extra_required_alignment var65;
struct unnamed_type_62_extra_size {
char a[sizeof(unnamed_type_62)+1];
char b;
};
struct unnamed_type_62_extra_size var66;
typedef struct {
#ifdef MSVC
__declspec(align(8)) unnamed_type_62 c;
#else
unnamed_type_62 c __attribute__((aligned(8)));
#endif
} J;
J var67;
struct J_extra_alignment {
char a;
J b;
};
struct J_extra_alignment var68;
#pragma pack(1)
struct J_extra_packed {
#ifdef MSVC
char a[sizeof(J)];
#else
J a;
#endif
};
#pragma pack()
struct J_extra_required_alignment {
char a;
struct J_extra_packed b;
};
struct J_extra_required_alignment var69;
struct J_extra_size {
char a[sizeof(J)+1];
char b;
};
struct J_extra_size var70;
#ifdef MSVC
typedef char unnamed_type_71[];
#else
typedef char unnamed_type_71[0];
#endif
unnamed_type_71 var72;
struct unnamed_type_71_extra_alignment {
char a;
unnamed_type_71 b;
};
struct unnamed_type_71_extra_alignment var73;
#pragma pack(1)
struct unnamed_type_71_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_71)];
#else
unnamed_type_71 a;
#endif
};
#pragma pack()
struct unnamed_type_71_extra_required_alignment {
char a;
struct unnamed_type_71_extra_packed b;
};
struct unnamed_type_71_extra_required_alignment var74;
struct unnamed_type_71_extra_size {
char a[sizeof(unnamed_type_71)+1];
char b;
};
struct unnamed_type_71_extra_size var75;
typedef struct {
#ifdef MSVC
__declspec(align(2)) unnamed_type_71 c;
#else
unnamed_type_71 c __attribute__((aligned(2)));
#endif
} K;
K var76;
struct K_extra_alignment {
char a;
K b;
};
struct K_extra_alignment var77;
#pragma pack(1)
struct K_extra_packed {
#ifdef MSVC
char a[sizeof(K)];
#else
K a;
#endif
};
#pragma pack()
struct K_extra_required_alignment {
char a;
struct K_extra_packed b;
};
struct K_extra_required_alignment var78;
struct K_extra_size {
char a[sizeof(K)+1];
char b;
};
struct K_extra_size var79;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-other-none:Clang|msp430-msp430-other-eabi:Clang|powerpc64-ppc64-freebsd-gnu:Clang|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv64-baseline_rv64-other-eabi:Clang|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownNone|Some("mipsel-mips32-other-none") Msp430NoneElf|Some("msp430-msp430-other-eabi") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 0, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 0, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 2, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 4, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 6, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,c) == 16, "");
#endif
_Static_assert(sizeof(F) == 0, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 0, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 2, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 16, "");
_Static_assert(_Alignof(G) == 8, "");
_Static_assert(sizeof(struct G_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 8, "");
_Static_assert(sizeof(struct G_extra_packed) == 16, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 18, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,c) == 64, "");
#endif
_Static_assert(sizeof(H) == 0, "");
_Static_assert(_Alignof(H) == 8, "");
_Static_assert(sizeof(struct H_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 8, "");
_Static_assert(sizeof(struct H_extra_packed) == 0, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 2, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 0, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 0, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 2, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 0, "");
_Static_assert(_Alignof(J) == 8, "");
_Static_assert(sizeof(struct J_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 8, "");
_Static_assert(sizeof(struct J_extra_packed) == 0, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 2, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 0, "");
_Static_assert(_Alignof(K) == 2, "");
_Static_assert(sizeof(struct K_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 2, "");
_Static_assert(sizeof(struct K_extra_packed) == 0, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 2, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 0, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 0, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 2, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 0, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 0, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 2, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 4, "");
_Static_assert(_Alignof(E) == 2, "");
_Static_assert(sizeof(struct E_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 2, "");
_Static_assert(sizeof(struct E_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 6, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,c) == 16, "");
#endif
_Static_assert(sizeof(F) == 0, "");
_Static_assert(_Alignof(F) == 2, "");
_Static_assert(sizeof(struct F_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 2, "");
_Static_assert(sizeof(struct F_extra_packed) == 0, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 2, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 16, "");
_Static_assert(_Alignof(G) == 16, "");
_Static_assert(sizeof(struct G_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 16, "");
_Static_assert(sizeof(struct G_extra_packed) == 16, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 18, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,c) == 64, "");
#endif
_Static_assert(sizeof(H) == 0, "");
_Static_assert(_Alignof(H) == 16, "");
_Static_assert(sizeof(struct H_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H_extra_packed) == 0, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 2, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 0, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 0, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 2, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 0, "");
_Static_assert(_Alignof(J) == 8, "");
_Static_assert(sizeof(struct J_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 8, "");
_Static_assert(sizeof(struct J_extra_packed) == 0, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 2, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 0, "");
_Static_assert(_Alignof(K) == 2, "");
_Static_assert(sizeof(struct K_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 2, "");
_Static_assert(sizeof(struct K_extra_packed) == 0, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 2, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc")
#elif defined(THREE)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 4, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 6, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 4, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 6, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,c) == 16, "");
#endif
_Static_assert(sizeof(F) == 4, "");
_Static_assert(_Alignof(F) == 8, "");
_Static_assert(sizeof(struct F_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 8, "");
_Static_assert(sizeof(struct F_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 6, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 16, "");
_Static_assert(_Alignof(G) == 16, "");
_Static_assert(sizeof(struct G_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 16, "");
_Static_assert(sizeof(struct G_extra_packed) == 16, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 18, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,c) == 64, "");
#endif
_Static_assert(sizeof(H) == 8, "");
_Static_assert(_Alignof(H) == 8, "");
_Static_assert(sizeof(struct H_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 8, "");
_Static_assert(sizeof(struct H_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 10, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 4, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 6, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 8, "");
_Static_assert(_Alignof(J) == 8, "");
_Static_assert(sizeof(struct J_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 8, "");
_Static_assert(sizeof(struct J_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 10, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 4, "");
_Static_assert(_Alignof(K) == 2, "");
_Static_assert(sizeof(struct K_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 2, "");
_Static_assert(sizeof(struct K_extra_packed) == 4, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 6, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
// MAPPING|FOUR|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 4, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 6, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 4, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 4, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 6, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,c) == 16, "");
#endif
_Static_assert(sizeof(F) == 4, "");
_Static_assert(_Alignof(F) == 8, "");
_Static_assert(sizeof(struct F_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 8, "");
_Static_assert(sizeof(struct F_extra_packed) == 4, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 6, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 16, "");
_Static_assert(_Alignof(G) == 16, "");
_Static_assert(sizeof(struct G_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 16, "");
_Static_assert(sizeof(struct G_extra_packed) == 16, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 18, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,c) == 64, "");
#endif
_Static_assert(sizeof(H) == 8, "");
_Static_assert(_Alignof(H) == 16, "");
_Static_assert(sizeof(struct H_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 16, "");
_Static_assert(sizeof(struct H_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 10, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
_Static_assert(sizeof(I) == 4, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 4, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 6, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 8, "");
_Static_assert(_Alignof(J) == 8, "");
_Static_assert(sizeof(struct J_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 8, "");
_Static_assert(sizeof(struct J_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 10, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
_Static_assert(sizeof(K) == 4, "");
_Static_assert(_Alignof(K) == 2, "");
_Static_assert(sizeof(struct K_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 2, "");
_Static_assert(sizeof(struct K_extra_packed) == 4, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 6, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0063_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(8)) typedef enum {
#else
typedef enum {
#endif
F1 = 1,
#ifdef MSVC
} A;
#else
} __attribute__((aligned(8))) A;
#endif
A var2;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var3;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var4;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var5;
#ifdef MSVC
__declspec(align(1)) typedef enum {
#else
typedef enum {
#endif
F6 = 1000,
#ifdef MSVC
} B;
#else
} __attribute__((aligned(1))) B;
#endif
B var7;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var8;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var9;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var10;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-netbsd-eabihf:Clang|x86-pentium4-ios-none:Clang|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-other-none:Clang|powerpc64-ppc64-freebsd-gnu:Clang|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv64-baseline_rv64-other-eabi:Clang|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") I386AppleIos|Some("x86-pentium4-ios-none") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownNone|Some("mipsel-mips32-other-none") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|THREE|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-windows-gnu:Gcc|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|END
// repr targets Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl")
#elif defined(THREE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|FIVE|hexagon-generic-linux-musl:Clang|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0029_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(4)) typedef char Char;
#else
typedef char Char __attribute__((aligned(4)));
#endif
Char var1;
struct Char_extra_alignment {
char a;
Char b;
};
struct Char_extra_alignment var2;
#pragma pack(1)
struct Char_extra_packed {
#ifdef MSVC
char a[sizeof(Char)];
#else
Char a;
#endif
};
#pragma pack()
struct Char_extra_required_alignment {
char a;
struct Char_extra_packed b;
};
struct Char_extra_required_alignment var3;
struct Char_extra_size {
char a[sizeof(Char)+1];
char b;
};
struct Char_extra_size var4;
typedef struct {
Char a;
} A;
A var5;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var6;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var7;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var8;
typedef struct {
Char a:1;
} B;
B var9;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var10;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var11;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var12;
#pragma pack(1)
typedef struct {
A a;
} C;
C var13;
#pragma pack()
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var14;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var15;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var16;
#pragma pack(1)
typedef struct {
B a;
} D;
D var17;
#pragma pack()
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var18;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var19;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var20;
typedef struct {
#ifdef MSVC
__declspec(align(8)) Char a;
#else
Char a __attribute__((aligned(8)));
#endif
} E;
E var21;
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var22;
#pragma pack(1)
struct E_extra_packed {
#ifdef MSVC
char a[sizeof(E)];
#else
E a;
#endif
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var23;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var24;
typedef struct {
#ifdef MSVC
__declspec(align(8)) Char a:1;
#else
Char a:1 __attribute__((aligned(8)));
#endif
} F;
F var25;
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var26;
#pragma pack(1)
struct F_extra_packed {
#ifdef MSVC
char a[sizeof(F)];
#else
F a;
#endif
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var27;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var28;
typedef struct {
#ifdef MSVC
__declspec(align(2)) Char a;
#else
Char a __attribute__((aligned(2)));
#endif
} G;
G var29;
struct G_extra_alignment {
char a;
G b;
};
struct G_extra_alignment var30;
#pragma pack(1)
struct G_extra_packed {
#ifdef MSVC
char a[sizeof(G)];
#else
G a;
#endif
};
#pragma pack()
struct G_extra_required_alignment {
char a;
struct G_extra_packed b;
};
struct G_extra_required_alignment var31;
struct G_extra_size {
char a[sizeof(G)+1];
char b;
};
struct G_extra_size var32;
typedef struct {
#ifdef MSVC
__declspec(align(2)) Char a:1;
#else
Char a:1 __attribute__((aligned(2)));
#endif
} H;
H var33;
struct H_extra_alignment {
char a;
H b;
};
struct H_extra_alignment var34;
#pragma pack(1)
struct H_extra_packed {
#ifdef MSVC
char a[sizeof(H)];
#else
H a;
#endif
};
#pragma pack()
struct H_extra_required_alignment {
char a;
struct H_extra_packed b;
};
struct H_extra_required_alignment var35;
struct H_extra_size {
char a[sizeof(H)+1];
char b;
};
struct H_extra_size var36;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|msp430-msp430-other-eabi:Clang|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Msp430NoneElf|Some("msp430-msp430-other-eabi") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(Char) == 1, "");
_Static_assert(_Alignof(Char) == 4, "");
_Static_assert(sizeof(struct Char_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Char_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Char_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Char_extra_packed) == 1, "");
_Static_assert(sizeof(struct Char_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Char_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Char_extra_size) == 3, "");
_Static_assert(_Alignof(struct Char_extra_size) == 1, "");
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 4, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 6, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 8, "");
_Static_assert(sizeof(struct F_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 8, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 4, "");
_Static_assert(_Alignof(G) == 4, "");
_Static_assert(sizeof(struct G_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 4, "");
_Static_assert(sizeof(struct G_extra_packed) == 4, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 6, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 4, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 4, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 6, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(Char) == 1, "");
_Static_assert(_Alignof(Char) == 4, "");
_Static_assert(sizeof(struct Char_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Char_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Char_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Char_extra_packed) == 1, "");
_Static_assert(sizeof(struct Char_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Char_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Char_extra_size) == 3, "");
_Static_assert(_Alignof(struct Char_extra_size) == 1, "");
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 4, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 4, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 6, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 8, "");
_Static_assert(sizeof(struct F_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 8, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 4, "");
_Static_assert(_Alignof(G) == 4, "");
_Static_assert(sizeof(struct G_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 4, "");
_Static_assert(sizeof(struct G_extra_packed) == 4, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 6, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 4, "");
_Static_assert(_Alignof(H) == 4, "");
_Static_assert(sizeof(struct H_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 4, "");
_Static_assert(sizeof(struct H_extra_packed) == 4, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 6, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|avr-avr2-other-eabi:Gcc|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(Char) == 1, "");
_Static_assert(_Alignof(Char) == 4, "");
_Static_assert(sizeof(struct Char_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Char_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Char_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Char_extra_packed) == 1, "");
_Static_assert(sizeof(struct Char_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Char_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Char_extra_size) == 3, "");
_Static_assert(_Alignof(struct Char_extra_size) == 1, "");
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
_Static_assert(sizeof(F) == 8, "");
_Static_assert(_Alignof(F) == 8, "");
_Static_assert(sizeof(struct F_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 8, "");
_Static_assert(sizeof(struct F_extra_packed) == 8, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 10, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
_Static_assert(sizeof(G) == 4, "");
_Static_assert(_Alignof(G) == 4, "");
_Static_assert(sizeof(struct G_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 4, "");
_Static_assert(sizeof(struct G_extra_packed) == 4, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 6, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
_Static_assert(sizeof(H) == 2, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 2, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 4, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0060_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef enum {
F1 = 1,
} __attribute__((packed)) A;
A var2;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var3;
#pragma pack(1)
struct A_extra_packed {
A a;
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var4;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var5;
typedef enum {
F6 = 1111,
} __attribute__((packed)) B;
B var7;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var8;
#pragma pack(1)
struct B_extra_packed {
B a;
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var9;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var10;
typedef enum {
F11 = 1,
} C;
C var12;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var13;
#pragma pack(1)
struct C_extra_packed {
C a;
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var14;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var15;
typedef enum {
F16 = 18764712120593,
} D;
D var17;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var18;
#pragma pack(1)
struct D_extra_packed {
D a;
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var19;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var20;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|x86-i686-windows-gnu:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") I686PcWindowsGnu|Some("x86-i686-windows-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|TWO|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(TWO)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|FOUR|hexagon-generic-linux-musl:Clang|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0023_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(8)) typedef struct {
#else
typedef struct {
#endif
char c;
#ifdef MSVC
} A;
#else
} __attribute__((aligned(8))) A;
#endif
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
#pragma pack(1)
#ifdef MSVC
__declspec(align(8)) typedef struct {
#else
typedef struct {
#endif
char c;
#ifdef MSVC
} B;
#else
} __attribute__((aligned(8))) B;
#endif
B var5;
#pragma pack()
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|avr-avr2-other-eabi:Gcc|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|msp430-msp430-other-eabi:Clang|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") AvrUnknownUnknown|Some("avr-avr2-other-eabi") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Msp430NoneElf|Some("msp430-msp430-other-eabi") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0088_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(1)
typedef long long A;
A var1;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
#pragma pack(1)
#ifdef MSVC
__declspec(align(2)) typedef long long D;
#else
typedef long long D __attribute__((aligned(2)));
#endif
D var5;
#pragma pack()
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var6;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var7;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-i686-windows-gnu:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I686PcWindowsGnu|Some("x86-i686-windows-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(THREE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0051_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(128)) typedef enum {
#else
typedef enum {
#endif
F1 = 1,
#ifdef MSVC
} A;
#else
} __attribute__((aligned(128))) A;
#endif
A var2;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var3;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var4;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var5;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-netbsd-eabihf:Clang|x86-pentium4-ios-none:Clang|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-other-none:Clang|powerpc64-ppc64-freebsd-gnu:Clang|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv64-baseline_rv64-other-eabi:Clang|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") I386AppleIos|Some("x86-pentium4-ios-none") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownNone|Some("mipsel-mips32-other-none") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|THREE|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-windows-gnu:Gcc|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|END
// repr targets Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl")
#elif defined(THREE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|FIVE|hexagon-generic-linux-musl:Clang|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 128, "");
_Static_assert(sizeof(struct A_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 128, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0054_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(2)
typedef enum {
F1 = 1,
} A;
A var2;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var3;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var4;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var5;
#pragma pack(2)
typedef enum {
F6 = 281474976710655,
} B;
B var7;
#pragma pack()
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var8;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var9;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var10;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|x86-i686-windows-gnu:Gcc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") I686PcWindowsGnu|Some("x86-i686-windows-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(THREE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|FIVE|hexagon-generic-linux-musl:Clang|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0022_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#pragma pack(1)
typedef struct {
#ifdef MSVC
__declspec(align(2)) char a:1;
#else
char a:1 __attribute__((aligned(2)));
#endif
} S2;
S2 var1;
#pragma pack()
struct S2_extra_alignment {
char a;
S2 b;
};
struct S2_extra_alignment var2;
#pragma pack(1)
struct S2_extra_packed {
#ifdef MSVC
char a[sizeof(S2)];
#else
S2 a;
#endif
};
#pragma pack()
struct S2_extra_required_alignment {
char a;
struct S2_extra_packed b;
};
struct S2_extra_required_alignment var3;
struct S2_extra_size {
char a[sizeof(S2)+1];
char b;
};
struct S2_extra_size var4;
#pragma pack(1)
typedef struct {
#ifdef MSVC
__declspec(align(4)) char a:1;
#else
char a:1 __attribute__((aligned(4)));
#endif
} S4;
S4 var5;
#pragma pack()
struct S4_extra_alignment {
char a;
S4 b;
};
struct S4_extra_alignment var6;
#pragma pack(1)
struct S4_extra_packed {
#ifdef MSVC
char a[sizeof(S4)];
#else
S4 a;
#endif
};
#pragma pack()
struct S4_extra_required_alignment {
char a;
struct S4_extra_packed b;
};
struct S4_extra_required_alignment var7;
struct S4_extra_size {
char a[sizeof(S4)+1];
char b;
};
struct S4_extra_size var8;
#pragma pack(1)
typedef struct {
#ifdef MSVC
__declspec(align(8)) char a:1;
#else
char a:1 __attribute__((aligned(8)));
#endif
} S8;
S8 var9;
#pragma pack()
struct S8_extra_alignment {
char a;
S8 b;
};
struct S8_extra_alignment var10;
#pragma pack(1)
struct S8_extra_packed {
#ifdef MSVC
char a[sizeof(S8)];
#else
S8 a;
#endif
};
#pragma pack()
struct S8_extra_required_alignment {
char a;
struct S8_extra_packed b;
};
struct S8_extra_required_alignment var11;
struct S8_extra_size {
char a[sizeof(S8)+1];
char b;
};
struct S8_extra_size var12;
#pragma pack(1)
typedef struct {
#ifdef MSVC
__declspec(align(16)) char a:1;
#else
char a:1 __attribute__((aligned(16)));
#endif
} S16;
S16 var13;
#pragma pack()
struct S16_extra_alignment {
char a;
S16 b;
};
struct S16_extra_alignment var14;
#pragma pack(1)
struct S16_extra_packed {
#ifdef MSVC
char a[sizeof(S16)];
#else
S16 a;
#endif
};
#pragma pack()
struct S16_extra_required_alignment {
char a;
struct S16_extra_packed b;
};
struct S16_extra_required_alignment var15;
struct S16_extra_size {
char a[sizeof(S16)+1];
char b;
};
struct S16_extra_size var16;
#pragma pack(1)
typedef struct {
#ifdef MSVC
__declspec(align(32)) char a:1;
#else
char a:1 __attribute__((aligned(32)));
#endif
} S32;
S32 var17;
#pragma pack()
struct S32_extra_alignment {
char a;
S32 b;
};
struct S32_extra_alignment var18;
#pragma pack(1)
struct S32_extra_packed {
#ifdef MSVC
char a[sizeof(S32)];
#else
S32 a;
#endif
};
#pragma pack()
struct S32_extra_required_alignment {
char a;
struct S32_extra_packed b;
};
struct S32_extra_required_alignment var19;
struct S32_extra_size {
char a[sizeof(S32)+1];
char b;
};
struct S32_extra_size var20;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|avr-avr2-other-eabi:Gcc|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|msp430-msp430-other-eabi:Clang|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") AvrUnknownUnknown|Some("avr-avr2-other-eabi") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Msp430NoneElf|Some("msp430-msp430-other-eabi") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(S2) == 1, "");
_Static_assert(_Alignof(S2) == 1, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 3, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
_Static_assert(sizeof(S4) == 1, "");
_Static_assert(_Alignof(S4) == 1, "");
_Static_assert(sizeof(struct S4_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S4_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S4_extra_packed) == 1, "");
_Static_assert(sizeof(struct S4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S4_extra_size) == 3, "");
_Static_assert(_Alignof(struct S4_extra_size) == 1, "");
_Static_assert(sizeof(S8) == 1, "");
_Static_assert(_Alignof(S8) == 1, "");
_Static_assert(sizeof(struct S8_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S8_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S8_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S8_extra_packed) == 1, "");
_Static_assert(sizeof(struct S8_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S8_extra_size) == 3, "");
_Static_assert(_Alignof(struct S8_extra_size) == 1, "");
_Static_assert(sizeof(S16) == 1, "");
_Static_assert(_Alignof(S16) == 1, "");
_Static_assert(sizeof(struct S16_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S16_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S16_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S16_extra_packed) == 1, "");
_Static_assert(sizeof(struct S16_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S16_extra_size) == 3, "");
_Static_assert(_Alignof(struct S16_extra_size) == 1, "");
_Static_assert(sizeof(S32) == 1, "");
_Static_assert(_Alignof(S32) == 1, "");
_Static_assert(sizeof(struct S32_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S32_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S32_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S32_extra_packed) == 1, "");
_Static_assert(sizeof(struct S32_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S32_extra_size) == 3, "");
_Static_assert(_Alignof(struct S32_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(S2) == 1, "");
_Static_assert(_Alignof(S2) == 2, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct S2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 3, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
_Static_assert(sizeof(S4) == 1, "");
_Static_assert(_Alignof(S4) == 4, "");
_Static_assert(sizeof(struct S4_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct S4_extra_alignment) == 4, "");
_Static_assert(sizeof(struct S4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S4_extra_packed) == 1, "");
_Static_assert(sizeof(struct S4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S4_extra_size) == 3, "");
_Static_assert(_Alignof(struct S4_extra_size) == 1, "");
_Static_assert(sizeof(S8) == 1, "");
_Static_assert(_Alignof(S8) == 8, "");
_Static_assert(sizeof(struct S8_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct S8_extra_alignment) == 8, "");
_Static_assert(sizeof(struct S8_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S8_extra_packed) == 1, "");
_Static_assert(sizeof(struct S8_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S8_extra_size) == 3, "");
_Static_assert(_Alignof(struct S8_extra_size) == 1, "");
_Static_assert(sizeof(S16) == 1, "");
_Static_assert(_Alignof(S16) == 16, "");
_Static_assert(sizeof(struct S16_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct S16_extra_alignment) == 16, "");
_Static_assert(sizeof(struct S16_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S16_extra_packed) == 1, "");
_Static_assert(sizeof(struct S16_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S16_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S16_extra_size) == 3, "");
_Static_assert(_Alignof(struct S16_extra_size) == 1, "");
_Static_assert(sizeof(S32) == 1, "");
_Static_assert(_Alignof(S32) == 32, "");
_Static_assert(sizeof(struct S32_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct S32_extra_alignment) == 32, "");
_Static_assert(sizeof(struct S32_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S32_extra_packed) == 1, "");
_Static_assert(sizeof(struct S32_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S32_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S32_extra_size) == 3, "");
_Static_assert(_Alignof(struct S32_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0015_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef union {
long:0;
char a:1;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef union {
char a:1;
long:0;
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 0, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None
#elif defined(TWO)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 0, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(THREE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 0, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FOUR|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 0, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FIVE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 0, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|SIX|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-linux-gnux32:Gcc|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32")
#elif defined(SIX)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 0, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|SEVEN|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SEVEN)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 0, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0056_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
int i;
} __attribute__((packed)) A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef union {
int i;
} __attribute__((packed)) B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-windows-msvc:Msvc|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-windows-msvc:Msvc|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-windows-msvc:Msvc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|x86-i686-uefi-msvc:Msvc|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-baseline-windows-msvc:Msvc|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") I686UnknownWindows|Some("x86-i686-uefi-msvc") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|TWO|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|THREE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0044_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char a;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
#ifdef MSVC
__declspec(align(4)) long long a;
#else
long long a __attribute__((aligned(4)));
#endif
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
#pragma pack(2)
typedef struct {
B a;
char b;
int c;
} X;
X var9;
#pragma pack()
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var10;
#pragma pack(1)
struct X_extra_packed {
#ifdef MSVC
char a[sizeof(X)];
#else
X a;
#endif
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var11;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var12;
#pragma pack(16)
typedef struct {
#ifdef MSVC
__declspec(align(32)) char:1;
#else
char:1 __attribute__((aligned(32)));
#endif
} YA;
YA var13;
#pragma pack()
struct YA_extra_alignment {
char a;
YA b;
};
struct YA_extra_alignment var14;
#pragma pack(1)
struct YA_extra_packed {
#ifdef MSVC
char a[sizeof(YA)];
#else
YA a;
#endif
};
#pragma pack()
struct YA_extra_required_alignment {
char a;
struct YA_extra_packed b;
};
struct YA_extra_required_alignment var15;
struct YA_extra_size {
char a[sizeof(YA)+1];
char b;
};
struct YA_extra_size var16;
#pragma pack(1)
typedef struct {
char a;
YA b;
} YB;
YB var17;
#pragma pack()
struct YB_extra_alignment {
char a;
YB b;
};
struct YB_extra_alignment var18;
#pragma pack(1)
struct YB_extra_packed {
#ifdef MSVC
char a[sizeof(YB)];
#else
YB a;
#endif
};
#pragma pack()
struct YB_extra_required_alignment {
char a;
struct YB_extra_packed b;
};
struct YB_extra_required_alignment var19;
struct YB_extra_size {
char a[sizeof(YB)+1];
char b;
};
struct YB_extra_size var20;
#pragma pack(8)
typedef struct {
#ifdef MSVC
__declspec(align(32)) char:1;
#else
char:1 __attribute__((aligned(32)));
#endif
} YC;
YC var21;
#pragma pack()
struct YC_extra_alignment {
char a;
YC b;
};
struct YC_extra_alignment var22;
#pragma pack(1)
struct YC_extra_packed {
#ifdef MSVC
char a[sizeof(YC)];
#else
YC a;
#endif
};
#pragma pack()
struct YC_extra_required_alignment {
char a;
struct YC_extra_packed b;
};
struct YC_extra_required_alignment var23;
struct YC_extra_size {
char a[sizeof(YC)+1];
char b;
};
struct YC_extra_size var24;
#pragma pack(1)
typedef struct {
char a;
YC b;
} YD;
YD var25;
#pragma pack()
struct YD_extra_alignment {
char a;
YD b;
};
struct YD_extra_alignment var26;
#pragma pack(1)
struct YD_extra_packed {
#ifdef MSVC
char a[sizeof(YD)];
#else
YD a;
#endif
};
#pragma pack()
struct YD_extra_required_alignment {
char a;
struct YD_extra_packed b;
};
struct YD_extra_required_alignment var27;
struct YD_extra_size {
char a[sizeof(YD)+1];
char b;
};
struct YD_extra_size var28;
#pragma pack(4)
typedef struct {
#ifdef MSVC
__declspec(align(32)) char:1;
#else
char:1 __attribute__((aligned(32)));
#endif
} YE;
YE var29;
#pragma pack()
struct YE_extra_alignment {
char a;
YE b;
};
struct YE_extra_alignment var30;
#pragma pack(1)
struct YE_extra_packed {
#ifdef MSVC
char a[sizeof(YE)];
#else
YE a;
#endif
};
#pragma pack()
struct YE_extra_required_alignment {
char a;
struct YE_extra_packed b;
};
struct YE_extra_required_alignment var31;
struct YE_extra_size {
char a[sizeof(YE)+1];
char b;
};
struct YE_extra_size var32;
#pragma pack(1)
typedef struct {
char a;
YE b;
} YF;
YF var33;
#pragma pack()
struct YF_extra_alignment {
char a;
YF b;
};
struct YF_extra_alignment var34;
#pragma pack(1)
struct YF_extra_packed {
#ifdef MSVC
char a[sizeof(YF)];
#else
YF a;
#endif
};
#pragma pack()
struct YF_extra_required_alignment {
char a;
struct YF_extra_packed b;
};
struct YF_extra_required_alignment var35;
struct YF_extra_size {
char a[sizeof(YF)+1];
char b;
};
struct YF_extra_size var36;
#pragma pack(16)
#ifdef MSVC
__declspec(align(16)) typedef struct {
#else
typedef struct {
#endif
char a;
#ifdef MSVC
} D0;
#else
} __attribute__((aligned(16))) D0;
#endif
D0 var37;
#pragma pack()
struct D0_extra_alignment {
char a;
D0 b;
};
struct D0_extra_alignment var38;
#pragma pack(1)
struct D0_extra_packed {
#ifdef MSVC
char a[sizeof(D0)];
#else
D0 a;
#endif
};
#pragma pack()
struct D0_extra_required_alignment {
char a;
struct D0_extra_packed b;
};
struct D0_extra_required_alignment var39;
struct D0_extra_size {
char a[sizeof(D0)+1];
char b;
};
struct D0_extra_size var40;
#pragma pack(1)
#ifdef MSVC
__declspec(align(8)) typedef struct {
__declspec(align(1024)) int b:3;
} RB0;
#else
typedef struct {
int b:3 __attribute__((aligned(1024)));
} __attribute__((aligned(8))) RB0;
#endif
RB0 var41;
#pragma pack()
struct RB0_extra_alignment {
char a;
RB0 b;
};
struct RB0_extra_alignment var42;
#pragma pack(1)
struct RB0_extra_packed {
#ifdef MSVC
char a[sizeof(RB0)];
#else
RB0 a;
#endif
};
#pragma pack()
struct RB0_extra_required_alignment {
char a;
struct RB0_extra_packed b;
};
struct RB0_extra_required_alignment var43;
struct RB0_extra_size {
char a[sizeof(RB0)+1];
char b;
};
struct RB0_extra_size var44;
#pragma pack(1)
typedef struct {
char a;
#ifdef MSVC
__declspec(align(1024)) int c:3;
#else
int c:3 __attribute__((aligned(1024)));
#endif
} RC;
RC var45;
#pragma pack()
struct RC_extra_alignment {
char a;
RC b;
};
struct RC_extra_alignment var46;
#pragma pack(1)
struct RC_extra_packed {
#ifdef MSVC
char a[sizeof(RC)];
#else
RC a;
#endif
};
#pragma pack()
struct RC_extra_required_alignment {
char a;
struct RC_extra_packed b;
};
struct RC_extra_required_alignment var47;
struct RC_extra_size {
char a[sizeof(RC)+1];
char b;
};
struct RC_extra_size var48;
#pragma pack(1)
typedef struct {
char a;
RC c;
} RE;
RE var49;
#pragma pack()
struct RE_extra_alignment {
char a;
RE b;
};
struct RE_extra_alignment var50;
#pragma pack(1)
struct RE_extra_packed {
#ifdef MSVC
char a[sizeof(RE)];
#else
RE a;
#endif
};
#pragma pack()
struct RE_extra_required_alignment {
char a;
struct RE_extra_packed b;
};
struct RE_extra_required_alignment var51;
struct RE_extra_size {
char a[sizeof(RE)+1];
char b;
};
struct RE_extra_size var52;
#ifdef MSVC
__declspec(align(4)) typedef struct {
#else
typedef struct {
#endif
int c;
#ifdef MSVC
} PA;
#else
} __attribute__((aligned(4))) PA;
#endif
PA var53;
struct PA_extra_alignment {
char a;
PA b;
};
struct PA_extra_alignment var54;
#pragma pack(1)
struct PA_extra_packed {
#ifdef MSVC
char a[sizeof(PA)];
#else
PA a;
#endif
};
#pragma pack()
struct PA_extra_required_alignment {
char a;
struct PA_extra_packed b;
};
struct PA_extra_required_alignment var55;
struct PA_extra_size {
char a[sizeof(PA)+1];
char b;
};
struct PA_extra_size var56;
#ifdef MSVC
__declspec(align(8)) typedef PA PB;
#else
typedef PA PB __attribute__((aligned(8)));
#endif
PB var57;
struct PB_extra_alignment {
char a;
PB b;
};
struct PB_extra_alignment var58;
#pragma pack(1)
struct PB_extra_packed {
#ifdef MSVC
char a[sizeof(PB)];
#else
PB a;
#endif
};
#pragma pack()
struct PB_extra_required_alignment {
char a;
struct PB_extra_packed b;
};
struct PB_extra_required_alignment var59;
struct PB_extra_size {
char a[sizeof(PB)+1];
char b;
};
struct PB_extra_size var60;
#pragma pack(1)
typedef struct {
char a;
PB x;
} PC;
PC var61;
#pragma pack()
struct PC_extra_alignment {
char a;
PC b;
};
struct PC_extra_alignment var62;
#pragma pack(1)
struct PC_extra_packed {
#ifdef MSVC
char a[sizeof(PC)];
#else
PC a;
#endif
};
#pragma pack()
struct PC_extra_required_alignment {
char a;
struct PC_extra_packed b;
};
struct PC_extra_required_alignment var63;
struct PC_extra_size {
char a[sizeof(PC)+1];
char b;
};
struct PC_extra_size var64;
typedef PB PD;
PD var65;
struct PD_extra_alignment {
char a;
PD b;
};
struct PD_extra_alignment var66;
#pragma pack(1)
struct PD_extra_packed {
#ifdef MSVC
char a[sizeof(PD)];
#else
PD a;
#endif
};
#pragma pack()
struct PD_extra_required_alignment {
char a;
struct PD_extra_packed b;
};
struct PD_extra_required_alignment var67;
struct PD_extra_size {
char a[sizeof(PD)+1];
char b;
};
struct PD_extra_size var68;
#pragma pack(1)
typedef struct {
char a;
PD x;
} PE;
PE var69;
#pragma pack()
struct PE_extra_alignment {
char a;
PE b;
};
struct PE_extra_alignment var70;
#pragma pack(1)
struct PE_extra_packed {
#ifdef MSVC
char a[sizeof(PE)];
#else
PE a;
#endif
};
#pragma pack()
struct PE_extra_required_alignment {
char a;
struct PE_extra_packed b;
};
struct PE_extra_required_alignment var71;
struct PE_extra_size {
char a[sizeof(PE)+1];
char b;
};
struct PE_extra_size var72;
#ifdef MSVC
__declspec(align(2)) typedef int QA;
#else
typedef int QA __attribute__((aligned(2)));
#endif
QA var73;
struct QA_extra_alignment {
char a;
QA b;
};
struct QA_extra_alignment var74;
#pragma pack(1)
struct QA_extra_packed {
#ifdef MSVC
char a[sizeof(QA)];
#else
QA a;
#endif
};
#pragma pack()
struct QA_extra_required_alignment {
char a;
struct QA_extra_packed b;
};
struct QA_extra_required_alignment var75;
struct QA_extra_size {
char a[sizeof(QA)+1];
char b;
};
struct QA_extra_size var76;
#pragma pack(1)
typedef struct {
char a;
QA b;
} QB;
QB var77;
#pragma pack()
struct QB_extra_alignment {
char a;
QB b;
};
struct QB_extra_alignment var78;
#pragma pack(1)
struct QB_extra_packed {
#ifdef MSVC
char a[sizeof(QB)];
#else
QB a;
#endif
};
#pragma pack()
struct QB_extra_required_alignment {
char a;
struct QB_extra_packed b;
};
struct QB_extra_required_alignment var79;
struct QB_extra_size {
char a[sizeof(QB)+1];
char b;
};
struct QB_extra_size var80;
typedef struct {
char a;
QA b;
} QC;
QC var81;
struct QC_extra_alignment {
char a;
QC b;
};
struct QC_extra_alignment var82;
#pragma pack(1)
struct QC_extra_packed {
#ifdef MSVC
char a[sizeof(QC)];
#else
QC a;
#endif
};
#pragma pack()
struct QC_extra_required_alignment {
char a;
struct QC_extra_packed b;
};
struct QC_extra_required_alignment var83;
struct QC_extra_size {
char a[sizeof(QC)+1];
char b;
};
struct QC_extra_size var84;
typedef struct {
char a;
QA b:3;
} QD;
QD var85;
struct QD_extra_alignment {
char a;
QD b;
};
struct QD_extra_alignment var86;
#pragma pack(1)
struct QD_extra_packed {
#ifdef MSVC
char a[sizeof(QD)];
#else
QD a;
#endif
};
#pragma pack()
struct QD_extra_required_alignment {
char a;
struct QD_extra_packed b;
};
struct QD_extra_required_alignment var87;
struct QD_extra_size {
char a[sizeof(QD)+1];
char b;
};
struct QD_extra_size var88;
#ifdef MSVC
typedef long long unnamed_type_89[];
#else
typedef long long unnamed_type_89[0];
#endif
unnamed_type_89 var90;
struct unnamed_type_89_extra_alignment {
char a;
unnamed_type_89 b;
};
struct unnamed_type_89_extra_alignment var91;
#pragma pack(1)
struct unnamed_type_89_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_89)];
#else
unnamed_type_89 a;
#endif
};
#pragma pack()
struct unnamed_type_89_extra_required_alignment {
char a;
struct unnamed_type_89_extra_packed b;
};
struct unnamed_type_89_extra_required_alignment var92;
struct unnamed_type_89_extra_size {
char a[sizeof(unnamed_type_89)+1];
char b;
};
struct unnamed_type_89_extra_size var93;
#ifdef MSVC
__declspec(align(4)) typedef struct {
#else
typedef struct {
#endif
unnamed_type_89 FlexArrayMemb;
#ifdef MSVC
} EmptyAlignedLongLongMemb;
#else
} __attribute__((aligned(4))) EmptyAlignedLongLongMemb;
#endif
EmptyAlignedLongLongMemb var94;
struct EmptyAlignedLongLongMemb_extra_alignment {
char a;
EmptyAlignedLongLongMemb b;
};
struct EmptyAlignedLongLongMemb_extra_alignment var95;
#pragma pack(1)
struct EmptyAlignedLongLongMemb_extra_packed {
#ifdef MSVC
char a[sizeof(EmptyAlignedLongLongMemb)];
#else
EmptyAlignedLongLongMemb a;
#endif
};
#pragma pack()
struct EmptyAlignedLongLongMemb_extra_required_alignment {
char a;
struct EmptyAlignedLongLongMemb_extra_packed b;
};
struct EmptyAlignedLongLongMemb_extra_required_alignment var96;
struct EmptyAlignedLongLongMemb_extra_size {
char a[sizeof(EmptyAlignedLongLongMemb)+1];
char b;
};
struct EmptyAlignedLongLongMemb_extra_size var97;
#ifdef MSVC
typedef long long unnamed_type_98[];
#else
typedef long long unnamed_type_98[0];
#endif
unnamed_type_98 var99;
struct unnamed_type_98_extra_alignment {
char a;
unnamed_type_98 b;
};
struct unnamed_type_98_extra_alignment var100;
#pragma pack(1)
struct unnamed_type_98_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_98)];
#else
unnamed_type_98 a;
#endif
};
#pragma pack()
struct unnamed_type_98_extra_required_alignment {
char a;
struct unnamed_type_98_extra_packed b;
};
struct unnamed_type_98_extra_required_alignment var101;
struct unnamed_type_98_extra_size {
char a[sizeof(unnamed_type_98)+1];
char b;
};
struct unnamed_type_98_extra_size var102;
#pragma pack(1)
#ifdef MSVC
__declspec(align(4)) typedef struct {
#else
typedef struct {
#endif
unnamed_type_98 FlexArrayMemb;
#ifdef MSVC
} EmptyPackedAlignedLongLongMemb;
#else
} __attribute__((aligned(4))) EmptyPackedAlignedLongLongMemb;
#endif
EmptyPackedAlignedLongLongMemb var103;
#pragma pack()
struct EmptyPackedAlignedLongLongMemb_extra_alignment {
char a;
EmptyPackedAlignedLongLongMemb b;
};
struct EmptyPackedAlignedLongLongMemb_extra_alignment var104;
#pragma pack(1)
struct EmptyPackedAlignedLongLongMemb_extra_packed {
#ifdef MSVC
char a[sizeof(EmptyPackedAlignedLongLongMemb)];
#else
EmptyPackedAlignedLongLongMemb a;
#endif
};
#pragma pack()
struct EmptyPackedAlignedLongLongMemb_extra_required_alignment {
char a;
struct EmptyPackedAlignedLongLongMemb_extra_packed b;
};
struct EmptyPackedAlignedLongLongMemb_extra_required_alignment var105;
struct EmptyPackedAlignedLongLongMemb_extra_size {
char a[sizeof(EmptyPackedAlignedLongLongMemb)+1];
char b;
};
struct EmptyPackedAlignedLongLongMemb_extra_size var106;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(X) == 14, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 14, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 15, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 16, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 80, "");
#endif
_Static_assert(sizeof(YA) == 1, "");
_Static_assert(_Alignof(YA) == 1, "");
_Static_assert(sizeof(struct YA_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct YA_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_packed) == 1, "");
_Static_assert(_Alignof(struct YA_extra_packed) == 1, "");
_Static_assert(sizeof(struct YA_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct YA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_size) == 3, "");
_Static_assert(_Alignof(struct YA_extra_size) == 1, "");
_Static_assert(sizeof(YB) == 2, "");
_Static_assert(_Alignof(YB) == 1, "");
_Static_assert(sizeof(struct YB_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct YB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_packed) == 2, "");
_Static_assert(_Alignof(struct YB_extra_packed) == 1, "");
_Static_assert(sizeof(struct YB_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct YB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_size) == 4, "");
_Static_assert(_Alignof(struct YB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YB,b) == 8, "");
#endif
_Static_assert(sizeof(YC) == 1, "");
_Static_assert(_Alignof(YC) == 1, "");
_Static_assert(sizeof(struct YC_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct YC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_packed) == 1, "");
_Static_assert(_Alignof(struct YC_extra_packed) == 1, "");
_Static_assert(sizeof(struct YC_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct YC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_size) == 3, "");
_Static_assert(_Alignof(struct YC_extra_size) == 1, "");
_Static_assert(sizeof(YD) == 2, "");
_Static_assert(_Alignof(YD) == 1, "");
_Static_assert(sizeof(struct YD_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct YD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_packed) == 2, "");
_Static_assert(_Alignof(struct YD_extra_packed) == 1, "");
_Static_assert(sizeof(struct YD_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct YD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_size) == 4, "");
_Static_assert(_Alignof(struct YD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YD,b) == 8, "");
#endif
_Static_assert(sizeof(YE) == 1, "");
_Static_assert(_Alignof(YE) == 1, "");
_Static_assert(sizeof(struct YE_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct YE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_packed) == 1, "");
_Static_assert(_Alignof(struct YE_extra_packed) == 1, "");
_Static_assert(sizeof(struct YE_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct YE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_size) == 3, "");
_Static_assert(_Alignof(struct YE_extra_size) == 1, "");
_Static_assert(sizeof(YF) == 2, "");
_Static_assert(_Alignof(YF) == 1, "");
_Static_assert(sizeof(struct YF_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct YF_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_packed) == 2, "");
_Static_assert(_Alignof(struct YF_extra_packed) == 1, "");
_Static_assert(sizeof(struct YF_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct YF_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_size) == 4, "");
_Static_assert(_Alignof(struct YF_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YF,b) == 8, "");
#endif
_Static_assert(sizeof(D0) == 16, "");
_Static_assert(_Alignof(D0) == 16, "");
_Static_assert(sizeof(struct D0_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D0_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D0_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D0_extra_packed) == 1, "");
_Static_assert(sizeof(struct D0_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D0_extra_size) == 18, "");
_Static_assert(_Alignof(struct D0_extra_size) == 1, "");
_Static_assert(sizeof(RB0) == 8, "");
_Static_assert(_Alignof(RB0) == 8, "");
_Static_assert(sizeof(struct RB0_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct RB0_extra_alignment) == 8, "");
_Static_assert(sizeof(struct RB0_extra_packed) == 8, "");
_Static_assert(_Alignof(struct RB0_extra_packed) == 1, "");
_Static_assert(sizeof(struct RB0_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct RB0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RB0_extra_size) == 10, "");
_Static_assert(_Alignof(struct RB0_extra_size) == 1, "");
_Static_assert(sizeof(RC) == 2, "");
_Static_assert(_Alignof(RC) == 1, "");
_Static_assert(sizeof(struct RC_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_packed) == 2, "");
_Static_assert(_Alignof(struct RC_extra_packed) == 1, "");
_Static_assert(sizeof(struct RC_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_size) == 4, "");
_Static_assert(_Alignof(struct RC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RC,c) == 8, "");
#endif
_Static_assert(sizeof(RE) == 3, "");
_Static_assert(_Alignof(RE) == 1, "");
_Static_assert(sizeof(struct RE_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_packed) == 3, "");
_Static_assert(_Alignof(struct RE_extra_packed) == 1, "");
_Static_assert(sizeof(struct RE_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_size) == 5, "");
_Static_assert(_Alignof(struct RE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RE,c) == 8, "");
#endif
_Static_assert(sizeof(PA) == 4, "");
_Static_assert(_Alignof(PA) == 4, "");
_Static_assert(sizeof(struct PA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct PA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct PA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PA_extra_packed) == 1, "");
_Static_assert(sizeof(struct PA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PA_extra_size) == 6, "");
_Static_assert(_Alignof(struct PA_extra_size) == 1, "");
_Static_assert(sizeof(PB) == 4, "");
_Static_assert(_Alignof(PB) == 8, "");
_Static_assert(sizeof(struct PB_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PB_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PB_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PB_extra_packed) == 1, "");
_Static_assert(sizeof(struct PB_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PB_extra_size) == 6, "");
_Static_assert(_Alignof(struct PB_extra_size) == 1, "");
_Static_assert(sizeof(PC) == 5, "");
_Static_assert(_Alignof(PC) == 1, "");
_Static_assert(sizeof(struct PC_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PC_extra_packed) == 1, "");
_Static_assert(sizeof(struct PC_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_size) == 7, "");
_Static_assert(_Alignof(struct PC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PC,x) == 8, "");
#endif
_Static_assert(sizeof(PD) == 4, "");
_Static_assert(_Alignof(PD) == 8, "");
_Static_assert(sizeof(struct PD_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PD_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PD_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PD_extra_packed) == 1, "");
_Static_assert(sizeof(struct PD_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PD_extra_size) == 6, "");
_Static_assert(_Alignof(struct PD_extra_size) == 1, "");
_Static_assert(sizeof(PE) == 5, "");
_Static_assert(_Alignof(PE) == 1, "");
_Static_assert(sizeof(struct PE_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PE_extra_packed) == 1, "");
_Static_assert(sizeof(struct PE_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_size) == 7, "");
_Static_assert(_Alignof(struct PE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PE,x) == 8, "");
#endif
_Static_assert(sizeof(QA) == 4, "");
_Static_assert(_Alignof(QA) == 2, "");
_Static_assert(sizeof(struct QA_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QA_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct QA_extra_packed) == 1, "");
_Static_assert(sizeof(struct QA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct QA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QA_extra_size) == 6, "");
_Static_assert(_Alignof(struct QA_extra_size) == 1, "");
_Static_assert(sizeof(QB) == 5, "");
_Static_assert(_Alignof(QB) == 1, "");
_Static_assert(sizeof(struct QB_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_packed) == 5, "");
_Static_assert(_Alignof(struct QB_extra_packed) == 1, "");
_Static_assert(sizeof(struct QB_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct QB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_size) == 7, "");
_Static_assert(_Alignof(struct QB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QB,b) == 8, "");
#endif
_Static_assert(sizeof(QC) == 6, "");
_Static_assert(_Alignof(QC) == 2, "");
_Static_assert(sizeof(struct QC_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QC_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QC_extra_packed) == 6, "");
_Static_assert(_Alignof(struct QC_extra_packed) == 1, "");
_Static_assert(sizeof(struct QC_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct QC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QC_extra_size) == 8, "");
_Static_assert(_Alignof(struct QC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QC,b) == 16, "");
#endif
_Static_assert(sizeof(QD) == 2, "");
_Static_assert(_Alignof(QD) == 2, "");
_Static_assert(sizeof(struct QD_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct QD_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QD_extra_packed) == 2, "");
_Static_assert(_Alignof(struct QD_extra_packed) == 1, "");
_Static_assert(sizeof(struct QD_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct QD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_size) == 4, "");
_Static_assert(_Alignof(struct QD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QD,b) == 8, "");
#endif
_Static_assert(sizeof(EmptyAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAlignedLongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(X) == 14, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 14, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 15, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 16, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 80, "");
#endif
_Static_assert(sizeof(YA) == 16, "");
_Static_assert(_Alignof(YA) == 16, "");
_Static_assert(sizeof(struct YA_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct YA_extra_alignment) == 16, "");
_Static_assert(sizeof(struct YA_extra_packed) == 16, "");
_Static_assert(_Alignof(struct YA_extra_packed) == 1, "");
_Static_assert(sizeof(struct YA_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct YA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_size) == 18, "");
_Static_assert(_Alignof(struct YA_extra_size) == 1, "");
_Static_assert(sizeof(YB) == 17, "");
_Static_assert(_Alignof(YB) == 1, "");
_Static_assert(sizeof(struct YB_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct YB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_packed) == 17, "");
_Static_assert(_Alignof(struct YB_extra_packed) == 1, "");
_Static_assert(sizeof(struct YB_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct YB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_size) == 19, "");
_Static_assert(_Alignof(struct YB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YB,b) == 8, "");
#endif
_Static_assert(sizeof(YC) == 8, "");
_Static_assert(_Alignof(YC) == 8, "");
_Static_assert(sizeof(struct YC_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct YC_extra_alignment) == 8, "");
_Static_assert(sizeof(struct YC_extra_packed) == 8, "");
_Static_assert(_Alignof(struct YC_extra_packed) == 1, "");
_Static_assert(sizeof(struct YC_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct YC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_size) == 10, "");
_Static_assert(_Alignof(struct YC_extra_size) == 1, "");
_Static_assert(sizeof(YD) == 9, "");
_Static_assert(_Alignof(YD) == 1, "");
_Static_assert(sizeof(struct YD_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_packed) == 9, "");
_Static_assert(_Alignof(struct YD_extra_packed) == 1, "");
_Static_assert(sizeof(struct YD_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_size) == 11, "");
_Static_assert(_Alignof(struct YD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YD,b) == 8, "");
#endif
_Static_assert(sizeof(YE) == 4, "");
_Static_assert(_Alignof(YE) == 4, "");
_Static_assert(sizeof(struct YE_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct YE_extra_alignment) == 4, "");
_Static_assert(sizeof(struct YE_extra_packed) == 4, "");
_Static_assert(_Alignof(struct YE_extra_packed) == 1, "");
_Static_assert(sizeof(struct YE_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct YE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_size) == 6, "");
_Static_assert(_Alignof(struct YE_extra_size) == 1, "");
_Static_assert(sizeof(YF) == 5, "");
_Static_assert(_Alignof(YF) == 1, "");
_Static_assert(sizeof(struct YF_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_packed) == 5, "");
_Static_assert(_Alignof(struct YF_extra_packed) == 1, "");
_Static_assert(sizeof(struct YF_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_size) == 7, "");
_Static_assert(_Alignof(struct YF_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YF,b) == 8, "");
#endif
_Static_assert(sizeof(D0) == 16, "");
_Static_assert(_Alignof(D0) == 16, "");
_Static_assert(sizeof(struct D0_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D0_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D0_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D0_extra_packed) == 1, "");
_Static_assert(sizeof(struct D0_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D0_extra_size) == 18, "");
_Static_assert(_Alignof(struct D0_extra_size) == 1, "");
_Static_assert(sizeof(RB0) == 8, "");
_Static_assert(_Alignof(RB0) == 8, "");
_Static_assert(sizeof(struct RB0_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct RB0_extra_alignment) == 8, "");
_Static_assert(sizeof(struct RB0_extra_packed) == 8, "");
_Static_assert(_Alignof(struct RB0_extra_packed) == 1, "");
_Static_assert(sizeof(struct RB0_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct RB0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RB0_extra_size) == 10, "");
_Static_assert(_Alignof(struct RB0_extra_size) == 1, "");
_Static_assert(sizeof(RC) == 2, "");
_Static_assert(_Alignof(RC) == 1, "");
_Static_assert(sizeof(struct RC_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_packed) == 2, "");
_Static_assert(_Alignof(struct RC_extra_packed) == 1, "");
_Static_assert(sizeof(struct RC_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_size) == 4, "");
_Static_assert(_Alignof(struct RC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RC,c) == 8, "");
#endif
_Static_assert(sizeof(RE) == 3, "");
_Static_assert(_Alignof(RE) == 1, "");
_Static_assert(sizeof(struct RE_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_packed) == 3, "");
_Static_assert(_Alignof(struct RE_extra_packed) == 1, "");
_Static_assert(sizeof(struct RE_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_size) == 5, "");
_Static_assert(_Alignof(struct RE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RE,c) == 8, "");
#endif
_Static_assert(sizeof(PA) == 4, "");
_Static_assert(_Alignof(PA) == 4, "");
_Static_assert(sizeof(struct PA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct PA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct PA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PA_extra_packed) == 1, "");
_Static_assert(sizeof(struct PA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PA_extra_size) == 6, "");
_Static_assert(_Alignof(struct PA_extra_size) == 1, "");
_Static_assert(sizeof(PB) == 4, "");
_Static_assert(_Alignof(PB) == 8, "");
_Static_assert(sizeof(struct PB_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PB_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PB_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PB_extra_packed) == 1, "");
_Static_assert(sizeof(struct PB_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PB_extra_size) == 6, "");
_Static_assert(_Alignof(struct PB_extra_size) == 1, "");
_Static_assert(sizeof(PC) == 5, "");
_Static_assert(_Alignof(PC) == 1, "");
_Static_assert(sizeof(struct PC_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PC_extra_packed) == 1, "");
_Static_assert(sizeof(struct PC_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_size) == 7, "");
_Static_assert(_Alignof(struct PC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PC,x) == 8, "");
#endif
_Static_assert(sizeof(PD) == 4, "");
_Static_assert(_Alignof(PD) == 8, "");
_Static_assert(sizeof(struct PD_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PD_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PD_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PD_extra_packed) == 1, "");
_Static_assert(sizeof(struct PD_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PD_extra_size) == 6, "");
_Static_assert(_Alignof(struct PD_extra_size) == 1, "");
_Static_assert(sizeof(PE) == 5, "");
_Static_assert(_Alignof(PE) == 1, "");
_Static_assert(sizeof(struct PE_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PE_extra_packed) == 1, "");
_Static_assert(sizeof(struct PE_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_size) == 7, "");
_Static_assert(_Alignof(struct PE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PE,x) == 8, "");
#endif
_Static_assert(sizeof(QA) == 4, "");
_Static_assert(_Alignof(QA) == 2, "");
_Static_assert(sizeof(struct QA_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QA_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct QA_extra_packed) == 1, "");
_Static_assert(sizeof(struct QA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct QA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QA_extra_size) == 6, "");
_Static_assert(_Alignof(struct QA_extra_size) == 1, "");
_Static_assert(sizeof(QB) == 5, "");
_Static_assert(_Alignof(QB) == 1, "");
_Static_assert(sizeof(struct QB_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_packed) == 5, "");
_Static_assert(_Alignof(struct QB_extra_packed) == 1, "");
_Static_assert(sizeof(struct QB_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct QB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_size) == 7, "");
_Static_assert(_Alignof(struct QB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QB,b) == 8, "");
#endif
_Static_assert(sizeof(QC) == 6, "");
_Static_assert(_Alignof(QC) == 2, "");
_Static_assert(sizeof(struct QC_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QC_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QC_extra_packed) == 6, "");
_Static_assert(_Alignof(struct QC_extra_packed) == 1, "");
_Static_assert(sizeof(struct QC_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct QC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QC_extra_size) == 8, "");
_Static_assert(_Alignof(struct QC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QC,b) == 16, "");
#endif
_Static_assert(sizeof(QD) == 2, "");
_Static_assert(_Alignof(QD) == 2, "");
_Static_assert(sizeof(struct QD_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct QD_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QD_extra_packed) == 2, "");
_Static_assert(_Alignof(struct QD_extra_packed) == 1, "");
_Static_assert(sizeof(struct QD_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct QD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_size) == 4, "");
_Static_assert(_Alignof(struct QD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QD,b) == 8, "");
#endif
_Static_assert(sizeof(EmptyAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAlignedLongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 1, "");
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(THREE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(X) == 16, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 20, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 18, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 80, "");
#endif
_Static_assert(sizeof(YA) == 32, "");
_Static_assert(_Alignof(YA) == 32, "");
_Static_assert(sizeof(struct YA_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct YA_extra_alignment) == 32, "");
_Static_assert(sizeof(struct YA_extra_packed) == 32, "");
_Static_assert(_Alignof(struct YA_extra_packed) == 1, "");
_Static_assert(sizeof(struct YA_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct YA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_size) == 34, "");
_Static_assert(_Alignof(struct YA_extra_size) == 1, "");
_Static_assert(sizeof(YB) == 33, "");
_Static_assert(_Alignof(YB) == 1, "");
_Static_assert(sizeof(struct YB_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct YB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_packed) == 33, "");
_Static_assert(_Alignof(struct YB_extra_packed) == 1, "");
_Static_assert(sizeof(struct YB_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct YB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_size) == 35, "");
_Static_assert(_Alignof(struct YB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YB,b) == 8, "");
#endif
_Static_assert(sizeof(YC) == 8, "");
_Static_assert(_Alignof(YC) == 32, "");
_Static_assert(sizeof(struct YC_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct YC_extra_alignment) == 32, "");
_Static_assert(sizeof(struct YC_extra_packed) == 8, "");
_Static_assert(_Alignof(struct YC_extra_packed) == 1, "");
_Static_assert(sizeof(struct YC_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct YC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_size) == 10, "");
_Static_assert(_Alignof(struct YC_extra_size) == 1, "");
_Static_assert(sizeof(YD) == 9, "");
_Static_assert(_Alignof(YD) == 1, "");
_Static_assert(sizeof(struct YD_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_packed) == 9, "");
_Static_assert(_Alignof(struct YD_extra_packed) == 1, "");
_Static_assert(sizeof(struct YD_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_size) == 11, "");
_Static_assert(_Alignof(struct YD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YD,b) == 8, "");
#endif
_Static_assert(sizeof(YE) == 4, "");
_Static_assert(_Alignof(YE) == 32, "");
_Static_assert(sizeof(struct YE_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct YE_extra_alignment) == 32, "");
_Static_assert(sizeof(struct YE_extra_packed) == 4, "");
_Static_assert(_Alignof(struct YE_extra_packed) == 1, "");
_Static_assert(sizeof(struct YE_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct YE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_size) == 6, "");
_Static_assert(_Alignof(struct YE_extra_size) == 1, "");
_Static_assert(sizeof(YF) == 5, "");
_Static_assert(_Alignof(YF) == 1, "");
_Static_assert(sizeof(struct YF_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_packed) == 5, "");
_Static_assert(_Alignof(struct YF_extra_packed) == 1, "");
_Static_assert(sizeof(struct YF_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_size) == 7, "");
_Static_assert(_Alignof(struct YF_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YF,b) == 8, "");
#endif
_Static_assert(sizeof(D0) == 16, "");
_Static_assert(_Alignof(D0) == 16, "");
_Static_assert(sizeof(struct D0_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D0_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D0_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D0_extra_packed) == 1, "");
_Static_assert(sizeof(struct D0_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D0_extra_size) == 18, "");
_Static_assert(_Alignof(struct D0_extra_size) == 1, "");
_Static_assert(sizeof(RB0) == 8, "");
_Static_assert(_Alignof(RB0) == 1024, "");
_Static_assert(sizeof(struct RB0_extra_alignment) == 2048, "");
_Static_assert(_Alignof(struct RB0_extra_alignment) == 1024, "");
_Static_assert(sizeof(struct RB0_extra_packed) == 8, "");
_Static_assert(_Alignof(struct RB0_extra_packed) == 1, "");
_Static_assert(sizeof(struct RB0_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct RB0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RB0_extra_size) == 10, "");
_Static_assert(_Alignof(struct RB0_extra_size) == 1, "");
_Static_assert(sizeof(RC) == 1028, "");
_Static_assert(_Alignof(RC) == 1024, "");
_Static_assert(sizeof(struct RC_extra_alignment) == 3072, "");
_Static_assert(_Alignof(struct RC_extra_alignment) == 1024, "");
_Static_assert(sizeof(struct RC_extra_packed) == 1028, "");
_Static_assert(_Alignof(struct RC_extra_packed) == 1, "");
_Static_assert(sizeof(struct RC_extra_required_alignment) == 1029, "");
_Static_assert(_Alignof(struct RC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_size) == 1030, "");
_Static_assert(_Alignof(struct RC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RC,c) == 8192, "");
#endif
_Static_assert(sizeof(RE) == 1029, "");
_Static_assert(_Alignof(RE) == 1, "");
_Static_assert(sizeof(struct RE_extra_alignment) == 1030, "");
_Static_assert(_Alignof(struct RE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_packed) == 1029, "");
_Static_assert(_Alignof(struct RE_extra_packed) == 1, "");
_Static_assert(sizeof(struct RE_extra_required_alignment) == 1030, "");
_Static_assert(_Alignof(struct RE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_size) == 1031, "");
_Static_assert(_Alignof(struct RE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RE,c) == 8, "");
#endif
_Static_assert(sizeof(PA) == 4, "");
_Static_assert(_Alignof(PA) == 4, "");
_Static_assert(sizeof(struct PA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct PA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct PA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PA_extra_packed) == 1, "");
_Static_assert(sizeof(struct PA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PA_extra_size) == 6, "");
_Static_assert(_Alignof(struct PA_extra_size) == 1, "");
_Static_assert(sizeof(PB) == 4, "");
_Static_assert(_Alignof(PB) == 8, "");
_Static_assert(sizeof(struct PB_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PB_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PB_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PB_extra_packed) == 1, "");
_Static_assert(sizeof(struct PB_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PB_extra_size) == 6, "");
_Static_assert(_Alignof(struct PB_extra_size) == 1, "");
_Static_assert(sizeof(PC) == 16, "");
_Static_assert(_Alignof(PC) == 8, "");
_Static_assert(sizeof(struct PC_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct PC_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PC_extra_packed) == 16, "");
_Static_assert(_Alignof(struct PC_extra_packed) == 1, "");
_Static_assert(sizeof(struct PC_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct PC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_size) == 18, "");
_Static_assert(_Alignof(struct PC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PC,x) == 64, "");
#endif
_Static_assert(sizeof(PD) == 4, "");
_Static_assert(_Alignof(PD) == 8, "");
_Static_assert(sizeof(struct PD_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PD_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PD_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PD_extra_packed) == 1, "");
_Static_assert(sizeof(struct PD_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PD_extra_size) == 6, "");
_Static_assert(_Alignof(struct PD_extra_size) == 1, "");
_Static_assert(sizeof(PE) == 16, "");
_Static_assert(_Alignof(PE) == 8, "");
_Static_assert(sizeof(struct PE_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct PE_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PE_extra_packed) == 16, "");
_Static_assert(_Alignof(struct PE_extra_packed) == 1, "");
_Static_assert(sizeof(struct PE_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct PE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_size) == 18, "");
_Static_assert(_Alignof(struct PE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PE,x) == 64, "");
#endif
_Static_assert(sizeof(QA) == 4, "");
_Static_assert(_Alignof(QA) == 4, "");
_Static_assert(sizeof(struct QA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct QA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct QA_extra_packed) == 1, "");
_Static_assert(sizeof(struct QA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct QA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QA_extra_size) == 6, "");
_Static_assert(_Alignof(struct QA_extra_size) == 1, "");
_Static_assert(sizeof(QB) == 6, "");
_Static_assert(_Alignof(QB) == 2, "");
_Static_assert(sizeof(struct QB_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QB_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QB_extra_packed) == 6, "");
_Static_assert(_Alignof(struct QB_extra_packed) == 1, "");
_Static_assert(sizeof(struct QB_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct QB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_size) == 8, "");
_Static_assert(_Alignof(struct QB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QB,b) == 16, "");
#endif
_Static_assert(sizeof(QC) == 8, "");
_Static_assert(_Alignof(QC) == 4, "");
_Static_assert(sizeof(struct QC_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct QC_extra_alignment) == 4, "");
_Static_assert(sizeof(struct QC_extra_packed) == 8, "");
_Static_assert(_Alignof(struct QC_extra_packed) == 1, "");
_Static_assert(sizeof(struct QC_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct QC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QC_extra_size) == 10, "");
_Static_assert(_Alignof(struct QC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QC,b) == 32, "");
#endif
_Static_assert(sizeof(QD) == 8, "");
_Static_assert(_Alignof(QD) == 4, "");
_Static_assert(sizeof(struct QD_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct QD_extra_alignment) == 4, "");
_Static_assert(sizeof(struct QD_extra_packed) == 8, "");
_Static_assert(_Alignof(struct QD_extra_packed) == 1, "");
_Static_assert(sizeof(struct QD_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct QD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_size) == 10, "");
_Static_assert(_Alignof(struct QD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QD,b) == 32, "");
#endif
_Static_assert(sizeof(EmptyAlignedLongLongMemb) == 4, "");
_Static_assert(_Alignof(EmptyAlignedLongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_packed) == 4, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_size) == 6, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(_Alignof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 6, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 1, "");
// MAPPING|FOUR|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(X) == 14, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 14, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 15, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 16, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 80, "");
#endif
_Static_assert(sizeof(YA) == 16, "");
_Static_assert(_Alignof(YA) == 16, "");
_Static_assert(sizeof(struct YA_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct YA_extra_alignment) == 16, "");
_Static_assert(sizeof(struct YA_extra_packed) == 16, "");
_Static_assert(_Alignof(struct YA_extra_packed) == 1, "");
_Static_assert(sizeof(struct YA_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct YA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_size) == 18, "");
_Static_assert(_Alignof(struct YA_extra_size) == 1, "");
_Static_assert(sizeof(YB) == 17, "");
_Static_assert(_Alignof(YB) == 1, "");
_Static_assert(sizeof(struct YB_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct YB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_packed) == 17, "");
_Static_assert(_Alignof(struct YB_extra_packed) == 1, "");
_Static_assert(sizeof(struct YB_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct YB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_size) == 19, "");
_Static_assert(_Alignof(struct YB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YB,b) == 8, "");
#endif
_Static_assert(sizeof(YC) == 8, "");
_Static_assert(_Alignof(YC) == 8, "");
_Static_assert(sizeof(struct YC_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct YC_extra_alignment) == 8, "");
_Static_assert(sizeof(struct YC_extra_packed) == 8, "");
_Static_assert(_Alignof(struct YC_extra_packed) == 1, "");
_Static_assert(sizeof(struct YC_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct YC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_size) == 10, "");
_Static_assert(_Alignof(struct YC_extra_size) == 1, "");
_Static_assert(sizeof(YD) == 9, "");
_Static_assert(_Alignof(YD) == 1, "");
_Static_assert(sizeof(struct YD_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_packed) == 9, "");
_Static_assert(_Alignof(struct YD_extra_packed) == 1, "");
_Static_assert(sizeof(struct YD_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_size) == 11, "");
_Static_assert(_Alignof(struct YD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YD,b) == 8, "");
#endif
_Static_assert(sizeof(YE) == 4, "");
_Static_assert(_Alignof(YE) == 4, "");
_Static_assert(sizeof(struct YE_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct YE_extra_alignment) == 4, "");
_Static_assert(sizeof(struct YE_extra_packed) == 4, "");
_Static_assert(_Alignof(struct YE_extra_packed) == 1, "");
_Static_assert(sizeof(struct YE_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct YE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_size) == 6, "");
_Static_assert(_Alignof(struct YE_extra_size) == 1, "");
_Static_assert(sizeof(YF) == 5, "");
_Static_assert(_Alignof(YF) == 1, "");
_Static_assert(sizeof(struct YF_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_packed) == 5, "");
_Static_assert(_Alignof(struct YF_extra_packed) == 1, "");
_Static_assert(sizeof(struct YF_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_size) == 7, "");
_Static_assert(_Alignof(struct YF_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YF,b) == 8, "");
#endif
_Static_assert(sizeof(D0) == 16, "");
_Static_assert(_Alignof(D0) == 16, "");
_Static_assert(sizeof(struct D0_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D0_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D0_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D0_extra_packed) == 1, "");
_Static_assert(sizeof(struct D0_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D0_extra_size) == 18, "");
_Static_assert(_Alignof(struct D0_extra_size) == 1, "");
_Static_assert(sizeof(RB0) == 8, "");
_Static_assert(_Alignof(RB0) == 8, "");
_Static_assert(sizeof(struct RB0_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct RB0_extra_alignment) == 8, "");
_Static_assert(sizeof(struct RB0_extra_packed) == 8, "");
_Static_assert(_Alignof(struct RB0_extra_packed) == 1, "");
_Static_assert(sizeof(struct RB0_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct RB0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RB0_extra_size) == 10, "");
_Static_assert(_Alignof(struct RB0_extra_size) == 1, "");
_Static_assert(sizeof(RC) == 2, "");
_Static_assert(_Alignof(RC) == 1, "");
_Static_assert(sizeof(struct RC_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_packed) == 2, "");
_Static_assert(_Alignof(struct RC_extra_packed) == 1, "");
_Static_assert(sizeof(struct RC_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_size) == 4, "");
_Static_assert(_Alignof(struct RC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RC,c) == 8, "");
#endif
_Static_assert(sizeof(RE) == 3, "");
_Static_assert(_Alignof(RE) == 1, "");
_Static_assert(sizeof(struct RE_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_packed) == 3, "");
_Static_assert(_Alignof(struct RE_extra_packed) == 1, "");
_Static_assert(sizeof(struct RE_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_size) == 5, "");
_Static_assert(_Alignof(struct RE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RE,c) == 8, "");
#endif
_Static_assert(sizeof(PA) == 4, "");
_Static_assert(_Alignof(PA) == 4, "");
_Static_assert(sizeof(struct PA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct PA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct PA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PA_extra_packed) == 1, "");
_Static_assert(sizeof(struct PA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PA_extra_size) == 6, "");
_Static_assert(_Alignof(struct PA_extra_size) == 1, "");
_Static_assert(sizeof(PB) == 4, "");
_Static_assert(_Alignof(PB) == 8, "");
_Static_assert(sizeof(struct PB_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PB_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PB_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PB_extra_packed) == 1, "");
_Static_assert(sizeof(struct PB_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PB_extra_size) == 6, "");
_Static_assert(_Alignof(struct PB_extra_size) == 1, "");
_Static_assert(sizeof(PC) == 5, "");
_Static_assert(_Alignof(PC) == 1, "");
_Static_assert(sizeof(struct PC_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PC_extra_packed) == 1, "");
_Static_assert(sizeof(struct PC_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_size) == 7, "");
_Static_assert(_Alignof(struct PC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PC,x) == 8, "");
#endif
_Static_assert(sizeof(PD) == 4, "");
_Static_assert(_Alignof(PD) == 8, "");
_Static_assert(sizeof(struct PD_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PD_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PD_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PD_extra_packed) == 1, "");
_Static_assert(sizeof(struct PD_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PD_extra_size) == 6, "");
_Static_assert(_Alignof(struct PD_extra_size) == 1, "");
_Static_assert(sizeof(PE) == 5, "");
_Static_assert(_Alignof(PE) == 1, "");
_Static_assert(sizeof(struct PE_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PE_extra_packed) == 1, "");
_Static_assert(sizeof(struct PE_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_size) == 7, "");
_Static_assert(_Alignof(struct PE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PE,x) == 8, "");
#endif
_Static_assert(sizeof(QA) == 4, "");
_Static_assert(_Alignof(QA) == 2, "");
_Static_assert(sizeof(struct QA_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QA_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct QA_extra_packed) == 1, "");
_Static_assert(sizeof(struct QA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct QA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QA_extra_size) == 6, "");
_Static_assert(_Alignof(struct QA_extra_size) == 1, "");
_Static_assert(sizeof(QB) == 5, "");
_Static_assert(_Alignof(QB) == 1, "");
_Static_assert(sizeof(struct QB_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_packed) == 5, "");
_Static_assert(_Alignof(struct QB_extra_packed) == 1, "");
_Static_assert(sizeof(struct QB_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct QB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_size) == 7, "");
_Static_assert(_Alignof(struct QB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QB,b) == 8, "");
#endif
_Static_assert(sizeof(QC) == 6, "");
_Static_assert(_Alignof(QC) == 2, "");
_Static_assert(sizeof(struct QC_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QC_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QC_extra_packed) == 6, "");
_Static_assert(_Alignof(struct QC_extra_packed) == 1, "");
_Static_assert(sizeof(struct QC_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct QC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QC_extra_size) == 8, "");
_Static_assert(_Alignof(struct QC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QC,b) == 16, "");
#endif
_Static_assert(sizeof(QD) == 2, "");
_Static_assert(_Alignof(QD) == 1, "");
_Static_assert(sizeof(struct QD_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct QD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_packed) == 2, "");
_Static_assert(_Alignof(struct QD_extra_packed) == 1, "");
_Static_assert(sizeof(struct QD_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct QD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_size) == 4, "");
_Static_assert(_Alignof(struct QD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QD,b) == 8, "");
#endif
_Static_assert(sizeof(EmptyAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 1, "");
// MAPPING|FIVE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(X) == 12, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 12, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 14, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 72, "");
#endif
_Static_assert(sizeof(YA) == 16, "");
_Static_assert(_Alignof(YA) == 16, "");
_Static_assert(sizeof(struct YA_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct YA_extra_alignment) == 16, "");
_Static_assert(sizeof(struct YA_extra_packed) == 16, "");
_Static_assert(_Alignof(struct YA_extra_packed) == 1, "");
_Static_assert(sizeof(struct YA_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct YA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_size) == 18, "");
_Static_assert(_Alignof(struct YA_extra_size) == 1, "");
_Static_assert(sizeof(YB) == 17, "");
_Static_assert(_Alignof(YB) == 1, "");
_Static_assert(sizeof(struct YB_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct YB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_packed) == 17, "");
_Static_assert(_Alignof(struct YB_extra_packed) == 1, "");
_Static_assert(sizeof(struct YB_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct YB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_size) == 19, "");
_Static_assert(_Alignof(struct YB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YB,b) == 8, "");
#endif
_Static_assert(sizeof(YC) == 8, "");
_Static_assert(_Alignof(YC) == 8, "");
_Static_assert(sizeof(struct YC_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct YC_extra_alignment) == 8, "");
_Static_assert(sizeof(struct YC_extra_packed) == 8, "");
_Static_assert(_Alignof(struct YC_extra_packed) == 1, "");
_Static_assert(sizeof(struct YC_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct YC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_size) == 10, "");
_Static_assert(_Alignof(struct YC_extra_size) == 1, "");
_Static_assert(sizeof(YD) == 9, "");
_Static_assert(_Alignof(YD) == 1, "");
_Static_assert(sizeof(struct YD_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_packed) == 9, "");
_Static_assert(_Alignof(struct YD_extra_packed) == 1, "");
_Static_assert(sizeof(struct YD_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_size) == 11, "");
_Static_assert(_Alignof(struct YD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YD,b) == 8, "");
#endif
_Static_assert(sizeof(YE) == 4, "");
_Static_assert(_Alignof(YE) == 4, "");
_Static_assert(sizeof(struct YE_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct YE_extra_alignment) == 4, "");
_Static_assert(sizeof(struct YE_extra_packed) == 4, "");
_Static_assert(_Alignof(struct YE_extra_packed) == 1, "");
_Static_assert(sizeof(struct YE_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct YE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_size) == 6, "");
_Static_assert(_Alignof(struct YE_extra_size) == 1, "");
_Static_assert(sizeof(YF) == 5, "");
_Static_assert(_Alignof(YF) == 1, "");
_Static_assert(sizeof(struct YF_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_packed) == 5, "");
_Static_assert(_Alignof(struct YF_extra_packed) == 1, "");
_Static_assert(sizeof(struct YF_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_size) == 7, "");
_Static_assert(_Alignof(struct YF_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YF,b) == 8, "");
#endif
_Static_assert(sizeof(D0) == 16, "");
_Static_assert(_Alignof(D0) == 16, "");
_Static_assert(sizeof(struct D0_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D0_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D0_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D0_extra_packed) == 1, "");
_Static_assert(sizeof(struct D0_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D0_extra_size) == 18, "");
_Static_assert(_Alignof(struct D0_extra_size) == 1, "");
_Static_assert(sizeof(RB0) == 8, "");
_Static_assert(_Alignof(RB0) == 8, "");
_Static_assert(sizeof(struct RB0_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct RB0_extra_alignment) == 8, "");
_Static_assert(sizeof(struct RB0_extra_packed) == 8, "");
_Static_assert(_Alignof(struct RB0_extra_packed) == 1, "");
_Static_assert(sizeof(struct RB0_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct RB0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RB0_extra_size) == 10, "");
_Static_assert(_Alignof(struct RB0_extra_size) == 1, "");
_Static_assert(sizeof(RC) == 2, "");
_Static_assert(_Alignof(RC) == 1, "");
_Static_assert(sizeof(struct RC_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_packed) == 2, "");
_Static_assert(_Alignof(struct RC_extra_packed) == 1, "");
_Static_assert(sizeof(struct RC_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_size) == 4, "");
_Static_assert(_Alignof(struct RC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RC,c) == 8, "");
#endif
_Static_assert(sizeof(RE) == 3, "");
_Static_assert(_Alignof(RE) == 1, "");
_Static_assert(sizeof(struct RE_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_packed) == 3, "");
_Static_assert(_Alignof(struct RE_extra_packed) == 1, "");
_Static_assert(sizeof(struct RE_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_size) == 5, "");
_Static_assert(_Alignof(struct RE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RE,c) == 8, "");
#endif
_Static_assert(sizeof(PA) == 4, "");
_Static_assert(_Alignof(PA) == 4, "");
_Static_assert(sizeof(struct PA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct PA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct PA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PA_extra_packed) == 1, "");
_Static_assert(sizeof(struct PA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PA_extra_size) == 6, "");
_Static_assert(_Alignof(struct PA_extra_size) == 1, "");
_Static_assert(sizeof(PB) == 4, "");
_Static_assert(_Alignof(PB) == 8, "");
_Static_assert(sizeof(struct PB_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PB_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PB_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PB_extra_packed) == 1, "");
_Static_assert(sizeof(struct PB_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PB_extra_size) == 6, "");
_Static_assert(_Alignof(struct PB_extra_size) == 1, "");
_Static_assert(sizeof(PC) == 5, "");
_Static_assert(_Alignof(PC) == 1, "");
_Static_assert(sizeof(struct PC_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PC_extra_packed) == 1, "");
_Static_assert(sizeof(struct PC_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_size) == 7, "");
_Static_assert(_Alignof(struct PC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PC,x) == 8, "");
#endif
_Static_assert(sizeof(PD) == 4, "");
_Static_assert(_Alignof(PD) == 8, "");
_Static_assert(sizeof(struct PD_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PD_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PD_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PD_extra_packed) == 1, "");
_Static_assert(sizeof(struct PD_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PD_extra_size) == 6, "");
_Static_assert(_Alignof(struct PD_extra_size) == 1, "");
_Static_assert(sizeof(PE) == 5, "");
_Static_assert(_Alignof(PE) == 1, "");
_Static_assert(sizeof(struct PE_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PE_extra_packed) == 1, "");
_Static_assert(sizeof(struct PE_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_size) == 7, "");
_Static_assert(_Alignof(struct PE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PE,x) == 8, "");
#endif
_Static_assert(sizeof(QA) == 2, "");
_Static_assert(_Alignof(QA) == 2, "");
_Static_assert(sizeof(struct QA_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct QA_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QA_extra_packed) == 2, "");
_Static_assert(_Alignof(struct QA_extra_packed) == 1, "");
_Static_assert(sizeof(struct QA_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct QA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QA_extra_size) == 4, "");
_Static_assert(_Alignof(struct QA_extra_size) == 1, "");
_Static_assert(sizeof(QB) == 3, "");
_Static_assert(_Alignof(QB) == 1, "");
_Static_assert(sizeof(struct QB_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct QB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_packed) == 3, "");
_Static_assert(_Alignof(struct QB_extra_packed) == 1, "");
_Static_assert(sizeof(struct QB_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct QB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_size) == 5, "");
_Static_assert(_Alignof(struct QB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QB,b) == 8, "");
#endif
_Static_assert(sizeof(QC) == 4, "");
_Static_assert(_Alignof(QC) == 2, "");
_Static_assert(sizeof(struct QC_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QC_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QC_extra_packed) == 4, "");
_Static_assert(_Alignof(struct QC_extra_packed) == 1, "");
_Static_assert(sizeof(struct QC_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct QC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QC_extra_size) == 6, "");
_Static_assert(_Alignof(struct QC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QC,b) == 16, "");
#endif
_Static_assert(sizeof(QD) == 2, "");
_Static_assert(_Alignof(QD) == 1, "");
_Static_assert(sizeof(struct QD_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct QD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_packed) == 2, "");
_Static_assert(_Alignof(struct QD_extra_packed) == 1, "");
_Static_assert(sizeof(struct QD_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct QD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_size) == 4, "");
_Static_assert(_Alignof(struct QD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QD,b) == 8, "");
#endif
_Static_assert(sizeof(EmptyAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 1, "");
// MAPPING|SIX|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(SIX)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(X) == 14, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 14, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 15, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 16, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 80, "");
#endif
_Static_assert(sizeof(YA) == 1, "");
_Static_assert(_Alignof(YA) == 1, "");
_Static_assert(sizeof(struct YA_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct YA_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_packed) == 1, "");
_Static_assert(_Alignof(struct YA_extra_packed) == 1, "");
_Static_assert(sizeof(struct YA_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct YA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_size) == 3, "");
_Static_assert(_Alignof(struct YA_extra_size) == 1, "");
_Static_assert(sizeof(YB) == 2, "");
_Static_assert(_Alignof(YB) == 1, "");
_Static_assert(sizeof(struct YB_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct YB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_packed) == 2, "");
_Static_assert(_Alignof(struct YB_extra_packed) == 1, "");
_Static_assert(sizeof(struct YB_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct YB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_size) == 4, "");
_Static_assert(_Alignof(struct YB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YB,b) == 8, "");
#endif
_Static_assert(sizeof(YC) == 1, "");
_Static_assert(_Alignof(YC) == 1, "");
_Static_assert(sizeof(struct YC_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct YC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_packed) == 1, "");
_Static_assert(_Alignof(struct YC_extra_packed) == 1, "");
_Static_assert(sizeof(struct YC_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct YC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_size) == 3, "");
_Static_assert(_Alignof(struct YC_extra_size) == 1, "");
_Static_assert(sizeof(YD) == 2, "");
_Static_assert(_Alignof(YD) == 1, "");
_Static_assert(sizeof(struct YD_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct YD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_packed) == 2, "");
_Static_assert(_Alignof(struct YD_extra_packed) == 1, "");
_Static_assert(sizeof(struct YD_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct YD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_size) == 4, "");
_Static_assert(_Alignof(struct YD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YD,b) == 8, "");
#endif
_Static_assert(sizeof(YE) == 1, "");
_Static_assert(_Alignof(YE) == 1, "");
_Static_assert(sizeof(struct YE_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct YE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_packed) == 1, "");
_Static_assert(_Alignof(struct YE_extra_packed) == 1, "");
_Static_assert(sizeof(struct YE_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct YE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_size) == 3, "");
_Static_assert(_Alignof(struct YE_extra_size) == 1, "");
_Static_assert(sizeof(YF) == 2, "");
_Static_assert(_Alignof(YF) == 1, "");
_Static_assert(sizeof(struct YF_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct YF_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_packed) == 2, "");
_Static_assert(_Alignof(struct YF_extra_packed) == 1, "");
_Static_assert(sizeof(struct YF_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct YF_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_size) == 4, "");
_Static_assert(_Alignof(struct YF_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YF,b) == 8, "");
#endif
_Static_assert(sizeof(D0) == 16, "");
_Static_assert(_Alignof(D0) == 16, "");
_Static_assert(sizeof(struct D0_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D0_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D0_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D0_extra_packed) == 1, "");
_Static_assert(sizeof(struct D0_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D0_extra_size) == 18, "");
_Static_assert(_Alignof(struct D0_extra_size) == 1, "");
_Static_assert(sizeof(RB0) == 8, "");
_Static_assert(_Alignof(RB0) == 8, "");
_Static_assert(sizeof(struct RB0_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct RB0_extra_alignment) == 8, "");
_Static_assert(sizeof(struct RB0_extra_packed) == 8, "");
_Static_assert(_Alignof(struct RB0_extra_packed) == 1, "");
_Static_assert(sizeof(struct RB0_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct RB0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RB0_extra_size) == 10, "");
_Static_assert(_Alignof(struct RB0_extra_size) == 1, "");
_Static_assert(sizeof(RC) == 2, "");
_Static_assert(_Alignof(RC) == 1, "");
_Static_assert(sizeof(struct RC_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_packed) == 2, "");
_Static_assert(_Alignof(struct RC_extra_packed) == 1, "");
_Static_assert(sizeof(struct RC_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_size) == 4, "");
_Static_assert(_Alignof(struct RC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RC,c) == 8, "");
#endif
_Static_assert(sizeof(RE) == 3, "");
_Static_assert(_Alignof(RE) == 1, "");
_Static_assert(sizeof(struct RE_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_packed) == 3, "");
_Static_assert(_Alignof(struct RE_extra_packed) == 1, "");
_Static_assert(sizeof(struct RE_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_size) == 5, "");
_Static_assert(_Alignof(struct RE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RE,c) == 8, "");
#endif
_Static_assert(sizeof(PA) == 4, "");
_Static_assert(_Alignof(PA) == 4, "");
_Static_assert(sizeof(struct PA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct PA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct PA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PA_extra_packed) == 1, "");
_Static_assert(sizeof(struct PA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PA_extra_size) == 6, "");
_Static_assert(_Alignof(struct PA_extra_size) == 1, "");
_Static_assert(sizeof(PB) == 4, "");
_Static_assert(_Alignof(PB) == 8, "");
_Static_assert(sizeof(struct PB_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PB_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PB_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PB_extra_packed) == 1, "");
_Static_assert(sizeof(struct PB_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PB_extra_size) == 6, "");
_Static_assert(_Alignof(struct PB_extra_size) == 1, "");
_Static_assert(sizeof(PC) == 5, "");
_Static_assert(_Alignof(PC) == 1, "");
_Static_assert(sizeof(struct PC_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PC_extra_packed) == 1, "");
_Static_assert(sizeof(struct PC_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_size) == 7, "");
_Static_assert(_Alignof(struct PC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PC,x) == 8, "");
#endif
_Static_assert(sizeof(PD) == 4, "");
_Static_assert(_Alignof(PD) == 8, "");
_Static_assert(sizeof(struct PD_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PD_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PD_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PD_extra_packed) == 1, "");
_Static_assert(sizeof(struct PD_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PD_extra_size) == 6, "");
_Static_assert(_Alignof(struct PD_extra_size) == 1, "");
_Static_assert(sizeof(PE) == 5, "");
_Static_assert(_Alignof(PE) == 1, "");
_Static_assert(sizeof(struct PE_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PE_extra_packed) == 1, "");
_Static_assert(sizeof(struct PE_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_size) == 7, "");
_Static_assert(_Alignof(struct PE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PE,x) == 8, "");
#endif
_Static_assert(sizeof(QA) == 4, "");
_Static_assert(_Alignof(QA) == 2, "");
_Static_assert(sizeof(struct QA_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QA_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct QA_extra_packed) == 1, "");
_Static_assert(sizeof(struct QA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct QA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QA_extra_size) == 6, "");
_Static_assert(_Alignof(struct QA_extra_size) == 1, "");
_Static_assert(sizeof(QB) == 5, "");
_Static_assert(_Alignof(QB) == 1, "");
_Static_assert(sizeof(struct QB_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_packed) == 5, "");
_Static_assert(_Alignof(struct QB_extra_packed) == 1, "");
_Static_assert(sizeof(struct QB_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct QB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_size) == 7, "");
_Static_assert(_Alignof(struct QB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QB,b) == 8, "");
#endif
_Static_assert(sizeof(QC) == 6, "");
_Static_assert(_Alignof(QC) == 2, "");
_Static_assert(sizeof(struct QC_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QC_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QC_extra_packed) == 6, "");
_Static_assert(_Alignof(struct QC_extra_packed) == 1, "");
_Static_assert(sizeof(struct QC_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct QC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QC_extra_size) == 8, "");
_Static_assert(_Alignof(struct QC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QC,b) == 16, "");
#endif
_Static_assert(sizeof(QD) == 2, "");
_Static_assert(_Alignof(QD) == 2, "");
_Static_assert(sizeof(struct QD_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct QD_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QD_extra_packed) == 2, "");
_Static_assert(_Alignof(struct QD_extra_packed) == 1, "");
_Static_assert(sizeof(struct QD_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct QD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_size) == 4, "");
_Static_assert(_Alignof(struct QD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QD,b) == 8, "");
#endif
_Static_assert(sizeof(EmptyAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 1, "");
// MAPPING|SEVEN|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|END
// repr targets I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc")
#elif defined(SEVEN)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(X) == 16, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 20, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 18, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 80, "");
#endif
_Static_assert(sizeof(YA) == 32, "");
_Static_assert(_Alignof(YA) == 32, "");
_Static_assert(sizeof(struct YA_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct YA_extra_alignment) == 32, "");
_Static_assert(sizeof(struct YA_extra_packed) == 32, "");
_Static_assert(_Alignof(struct YA_extra_packed) == 1, "");
_Static_assert(sizeof(struct YA_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct YA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_size) == 34, "");
_Static_assert(_Alignof(struct YA_extra_size) == 1, "");
_Static_assert(sizeof(YB) == 33, "");
_Static_assert(_Alignof(YB) == 1, "");
_Static_assert(sizeof(struct YB_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct YB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_packed) == 33, "");
_Static_assert(_Alignof(struct YB_extra_packed) == 1, "");
_Static_assert(sizeof(struct YB_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct YB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_size) == 35, "");
_Static_assert(_Alignof(struct YB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YB,b) == 8, "");
#endif
_Static_assert(sizeof(YC) == 32, "");
_Static_assert(_Alignof(YC) == 32, "");
_Static_assert(sizeof(struct YC_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct YC_extra_alignment) == 32, "");
_Static_assert(sizeof(struct YC_extra_packed) == 32, "");
_Static_assert(_Alignof(struct YC_extra_packed) == 1, "");
_Static_assert(sizeof(struct YC_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct YC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_size) == 34, "");
_Static_assert(_Alignof(struct YC_extra_size) == 1, "");
_Static_assert(sizeof(YD) == 33, "");
_Static_assert(_Alignof(YD) == 1, "");
_Static_assert(sizeof(struct YD_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct YD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_packed) == 33, "");
_Static_assert(_Alignof(struct YD_extra_packed) == 1, "");
_Static_assert(sizeof(struct YD_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct YD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_size) == 35, "");
_Static_assert(_Alignof(struct YD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YD,b) == 8, "");
#endif
_Static_assert(sizeof(YE) == 4, "");
_Static_assert(_Alignof(YE) == 32, "");
_Static_assert(sizeof(struct YE_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct YE_extra_alignment) == 32, "");
_Static_assert(sizeof(struct YE_extra_packed) == 4, "");
_Static_assert(_Alignof(struct YE_extra_packed) == 1, "");
_Static_assert(sizeof(struct YE_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct YE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_size) == 6, "");
_Static_assert(_Alignof(struct YE_extra_size) == 1, "");
_Static_assert(sizeof(YF) == 5, "");
_Static_assert(_Alignof(YF) == 1, "");
_Static_assert(sizeof(struct YF_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_packed) == 5, "");
_Static_assert(_Alignof(struct YF_extra_packed) == 1, "");
_Static_assert(sizeof(struct YF_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_size) == 7, "");
_Static_assert(_Alignof(struct YF_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YF,b) == 8, "");
#endif
_Static_assert(sizeof(D0) == 16, "");
_Static_assert(_Alignof(D0) == 16, "");
_Static_assert(sizeof(struct D0_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D0_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D0_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D0_extra_packed) == 1, "");
_Static_assert(sizeof(struct D0_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D0_extra_size) == 18, "");
_Static_assert(_Alignof(struct D0_extra_size) == 1, "");
_Static_assert(sizeof(RB0) == 8, "");
_Static_assert(_Alignof(RB0) == 1024, "");
_Static_assert(sizeof(struct RB0_extra_alignment) == 2048, "");
_Static_assert(_Alignof(struct RB0_extra_alignment) == 1024, "");
_Static_assert(sizeof(struct RB0_extra_packed) == 8, "");
_Static_assert(_Alignof(struct RB0_extra_packed) == 1, "");
_Static_assert(sizeof(struct RB0_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct RB0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RB0_extra_size) == 10, "");
_Static_assert(_Alignof(struct RB0_extra_size) == 1, "");
_Static_assert(sizeof(RC) == 1028, "");
_Static_assert(_Alignof(RC) == 1024, "");
_Static_assert(sizeof(struct RC_extra_alignment) == 3072, "");
_Static_assert(_Alignof(struct RC_extra_alignment) == 1024, "");
_Static_assert(sizeof(struct RC_extra_packed) == 1028, "");
_Static_assert(_Alignof(struct RC_extra_packed) == 1, "");
_Static_assert(sizeof(struct RC_extra_required_alignment) == 1029, "");
_Static_assert(_Alignof(struct RC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_size) == 1030, "");
_Static_assert(_Alignof(struct RC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RC,c) == 8192, "");
#endif
_Static_assert(sizeof(RE) == 1029, "");
_Static_assert(_Alignof(RE) == 1, "");
_Static_assert(sizeof(struct RE_extra_alignment) == 1030, "");
_Static_assert(_Alignof(struct RE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_packed) == 1029, "");
_Static_assert(_Alignof(struct RE_extra_packed) == 1, "");
_Static_assert(sizeof(struct RE_extra_required_alignment) == 1030, "");
_Static_assert(_Alignof(struct RE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_size) == 1031, "");
_Static_assert(_Alignof(struct RE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RE,c) == 8, "");
#endif
_Static_assert(sizeof(PA) == 4, "");
_Static_assert(_Alignof(PA) == 4, "");
_Static_assert(sizeof(struct PA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct PA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct PA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PA_extra_packed) == 1, "");
_Static_assert(sizeof(struct PA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PA_extra_size) == 6, "");
_Static_assert(_Alignof(struct PA_extra_size) == 1, "");
_Static_assert(sizeof(PB) == 4, "");
_Static_assert(_Alignof(PB) == 8, "");
_Static_assert(sizeof(struct PB_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PB_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PB_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PB_extra_packed) == 1, "");
_Static_assert(sizeof(struct PB_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PB_extra_size) == 6, "");
_Static_assert(_Alignof(struct PB_extra_size) == 1, "");
_Static_assert(sizeof(PC) == 16, "");
_Static_assert(_Alignof(PC) == 8, "");
_Static_assert(sizeof(struct PC_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct PC_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PC_extra_packed) == 16, "");
_Static_assert(_Alignof(struct PC_extra_packed) == 1, "");
_Static_assert(sizeof(struct PC_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct PC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_size) == 18, "");
_Static_assert(_Alignof(struct PC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PC,x) == 64, "");
#endif
_Static_assert(sizeof(PD) == 4, "");
_Static_assert(_Alignof(PD) == 8, "");
_Static_assert(sizeof(struct PD_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PD_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PD_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PD_extra_packed) == 1, "");
_Static_assert(sizeof(struct PD_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PD_extra_size) == 6, "");
_Static_assert(_Alignof(struct PD_extra_size) == 1, "");
_Static_assert(sizeof(PE) == 16, "");
_Static_assert(_Alignof(PE) == 8, "");
_Static_assert(sizeof(struct PE_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct PE_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PE_extra_packed) == 16, "");
_Static_assert(_Alignof(struct PE_extra_packed) == 1, "");
_Static_assert(sizeof(struct PE_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct PE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_size) == 18, "");
_Static_assert(_Alignof(struct PE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PE,x) == 64, "");
#endif
_Static_assert(sizeof(QA) == 4, "");
_Static_assert(_Alignof(QA) == 4, "");
_Static_assert(sizeof(struct QA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct QA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct QA_extra_packed) == 1, "");
_Static_assert(sizeof(struct QA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct QA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QA_extra_size) == 6, "");
_Static_assert(_Alignof(struct QA_extra_size) == 1, "");
_Static_assert(sizeof(QB) == 6, "");
_Static_assert(_Alignof(QB) == 2, "");
_Static_assert(sizeof(struct QB_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QB_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QB_extra_packed) == 6, "");
_Static_assert(_Alignof(struct QB_extra_packed) == 1, "");
_Static_assert(sizeof(struct QB_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct QB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_size) == 8, "");
_Static_assert(_Alignof(struct QB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QB,b) == 16, "");
#endif
_Static_assert(sizeof(QC) == 8, "");
_Static_assert(_Alignof(QC) == 4, "");
_Static_assert(sizeof(struct QC_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct QC_extra_alignment) == 4, "");
_Static_assert(sizeof(struct QC_extra_packed) == 8, "");
_Static_assert(_Alignof(struct QC_extra_packed) == 1, "");
_Static_assert(sizeof(struct QC_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct QC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QC_extra_size) == 10, "");
_Static_assert(_Alignof(struct QC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QC,b) == 32, "");
#endif
_Static_assert(sizeof(QD) == 8, "");
_Static_assert(_Alignof(QD) == 4, "");
_Static_assert(sizeof(struct QD_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct QD_extra_alignment) == 4, "");
_Static_assert(sizeof(struct QD_extra_packed) == 8, "");
_Static_assert(_Alignof(struct QD_extra_packed) == 1, "");
_Static_assert(sizeof(struct QD_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct QD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_size) == 10, "");
_Static_assert(_Alignof(struct QD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QD,b) == 32, "");
#endif
_Static_assert(sizeof(EmptyAlignedLongLongMemb) == 4, "");
_Static_assert(_Alignof(EmptyAlignedLongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_packed) == 4, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_size) == 6, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(_Alignof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 6, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 1, "");
// MAPPING|EIGHT|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(EIGHT)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(X) == 14, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 14, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 15, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 16, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 80, "");
#endif
_Static_assert(sizeof(YA) == 16, "");
_Static_assert(_Alignof(YA) == 16, "");
_Static_assert(sizeof(struct YA_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct YA_extra_alignment) == 16, "");
_Static_assert(sizeof(struct YA_extra_packed) == 16, "");
_Static_assert(_Alignof(struct YA_extra_packed) == 1, "");
_Static_assert(sizeof(struct YA_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct YA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_size) == 18, "");
_Static_assert(_Alignof(struct YA_extra_size) == 1, "");
_Static_assert(sizeof(YB) == 17, "");
_Static_assert(_Alignof(YB) == 1, "");
_Static_assert(sizeof(struct YB_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct YB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_packed) == 17, "");
_Static_assert(_Alignof(struct YB_extra_packed) == 1, "");
_Static_assert(sizeof(struct YB_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct YB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_size) == 19, "");
_Static_assert(_Alignof(struct YB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YB,b) == 8, "");
#endif
_Static_assert(sizeof(YC) == 8, "");
_Static_assert(_Alignof(YC) == 8, "");
_Static_assert(sizeof(struct YC_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct YC_extra_alignment) == 8, "");
_Static_assert(sizeof(struct YC_extra_packed) == 8, "");
_Static_assert(_Alignof(struct YC_extra_packed) == 1, "");
_Static_assert(sizeof(struct YC_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct YC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_size) == 10, "");
_Static_assert(_Alignof(struct YC_extra_size) == 1, "");
_Static_assert(sizeof(YD) == 9, "");
_Static_assert(_Alignof(YD) == 1, "");
_Static_assert(sizeof(struct YD_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_packed) == 9, "");
_Static_assert(_Alignof(struct YD_extra_packed) == 1, "");
_Static_assert(sizeof(struct YD_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_size) == 11, "");
_Static_assert(_Alignof(struct YD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YD,b) == 8, "");
#endif
_Static_assert(sizeof(YE) == 4, "");
_Static_assert(_Alignof(YE) == 4, "");
_Static_assert(sizeof(struct YE_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct YE_extra_alignment) == 4, "");
_Static_assert(sizeof(struct YE_extra_packed) == 4, "");
_Static_assert(_Alignof(struct YE_extra_packed) == 1, "");
_Static_assert(sizeof(struct YE_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct YE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_size) == 6, "");
_Static_assert(_Alignof(struct YE_extra_size) == 1, "");
_Static_assert(sizeof(YF) == 5, "");
_Static_assert(_Alignof(YF) == 1, "");
_Static_assert(sizeof(struct YF_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_packed) == 5, "");
_Static_assert(_Alignof(struct YF_extra_packed) == 1, "");
_Static_assert(sizeof(struct YF_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_size) == 7, "");
_Static_assert(_Alignof(struct YF_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YF,b) == 8, "");
#endif
_Static_assert(sizeof(D0) == 16, "");
_Static_assert(_Alignof(D0) == 16, "");
_Static_assert(sizeof(struct D0_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D0_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D0_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D0_extra_packed) == 1, "");
_Static_assert(sizeof(struct D0_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D0_extra_size) == 18, "");
_Static_assert(_Alignof(struct D0_extra_size) == 1, "");
_Static_assert(sizeof(RB0) == 8, "");
_Static_assert(_Alignof(RB0) == 8, "");
_Static_assert(sizeof(struct RB0_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct RB0_extra_alignment) == 8, "");
_Static_assert(sizeof(struct RB0_extra_packed) == 8, "");
_Static_assert(_Alignof(struct RB0_extra_packed) == 1, "");
_Static_assert(sizeof(struct RB0_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct RB0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RB0_extra_size) == 10, "");
_Static_assert(_Alignof(struct RB0_extra_size) == 1, "");
_Static_assert(sizeof(RC) == 5, "");
_Static_assert(_Alignof(RC) == 1, "");
_Static_assert(sizeof(struct RC_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct RC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_packed) == 5, "");
_Static_assert(_Alignof(struct RC_extra_packed) == 1, "");
_Static_assert(sizeof(struct RC_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct RC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_size) == 7, "");
_Static_assert(_Alignof(struct RC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RC,c) == 8, "");
#endif
_Static_assert(sizeof(RE) == 6, "");
_Static_assert(_Alignof(RE) == 1, "");
_Static_assert(sizeof(struct RE_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct RE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_packed) == 6, "");
_Static_assert(_Alignof(struct RE_extra_packed) == 1, "");
_Static_assert(sizeof(struct RE_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct RE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_size) == 8, "");
_Static_assert(_Alignof(struct RE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RE,c) == 8, "");
#endif
_Static_assert(sizeof(PA) == 4, "");
_Static_assert(_Alignof(PA) == 4, "");
_Static_assert(sizeof(struct PA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct PA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct PA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PA_extra_packed) == 1, "");
_Static_assert(sizeof(struct PA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PA_extra_size) == 6, "");
_Static_assert(_Alignof(struct PA_extra_size) == 1, "");
_Static_assert(sizeof(PB) == 4, "");
_Static_assert(_Alignof(PB) == 8, "");
_Static_assert(sizeof(struct PB_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PB_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PB_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PB_extra_packed) == 1, "");
_Static_assert(sizeof(struct PB_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PB_extra_size) == 6, "");
_Static_assert(_Alignof(struct PB_extra_size) == 1, "");
_Static_assert(sizeof(PC) == 5, "");
_Static_assert(_Alignof(PC) == 1, "");
_Static_assert(sizeof(struct PC_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PC_extra_packed) == 1, "");
_Static_assert(sizeof(struct PC_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_size) == 7, "");
_Static_assert(_Alignof(struct PC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PC,x) == 8, "");
#endif
_Static_assert(sizeof(PD) == 4, "");
_Static_assert(_Alignof(PD) == 8, "");
_Static_assert(sizeof(struct PD_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PD_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PD_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PD_extra_packed) == 1, "");
_Static_assert(sizeof(struct PD_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PD_extra_size) == 6, "");
_Static_assert(_Alignof(struct PD_extra_size) == 1, "");
_Static_assert(sizeof(PE) == 5, "");
_Static_assert(_Alignof(PE) == 1, "");
_Static_assert(sizeof(struct PE_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PE_extra_packed) == 1, "");
_Static_assert(sizeof(struct PE_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_size) == 7, "");
_Static_assert(_Alignof(struct PE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PE,x) == 8, "");
#endif
_Static_assert(sizeof(QA) == 4, "");
_Static_assert(_Alignof(QA) == 2, "");
_Static_assert(sizeof(struct QA_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QA_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct QA_extra_packed) == 1, "");
_Static_assert(sizeof(struct QA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct QA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QA_extra_size) == 6, "");
_Static_assert(_Alignof(struct QA_extra_size) == 1, "");
_Static_assert(sizeof(QB) == 5, "");
_Static_assert(_Alignof(QB) == 1, "");
_Static_assert(sizeof(struct QB_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_packed) == 5, "");
_Static_assert(_Alignof(struct QB_extra_packed) == 1, "");
_Static_assert(sizeof(struct QB_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct QB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_size) == 7, "");
_Static_assert(_Alignof(struct QB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QB,b) == 8, "");
#endif
_Static_assert(sizeof(QC) == 6, "");
_Static_assert(_Alignof(QC) == 2, "");
_Static_assert(sizeof(struct QC_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QC_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QC_extra_packed) == 6, "");
_Static_assert(_Alignof(struct QC_extra_packed) == 1, "");
_Static_assert(sizeof(struct QC_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct QC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QC_extra_size) == 8, "");
_Static_assert(_Alignof(struct QC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QC,b) == 16, "");
#endif
_Static_assert(sizeof(QD) == 6, "");
_Static_assert(_Alignof(QD) == 2, "");
_Static_assert(sizeof(struct QD_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QD_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QD_extra_packed) == 6, "");
_Static_assert(_Alignof(struct QD_extra_packed) == 1, "");
_Static_assert(sizeof(struct QD_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct QD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_size) == 8, "");
_Static_assert(_Alignof(struct QD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QD,b) == 16, "");
#endif
_Static_assert(sizeof(EmptyAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAlignedLongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 1, "");
// MAPPING|NINE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(NINE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(X) == 12, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 12, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 14, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 80, "");
#endif
_Static_assert(sizeof(YA) == 1, "");
_Static_assert(_Alignof(YA) == 1, "");
_Static_assert(sizeof(struct YA_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct YA_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_packed) == 1, "");
_Static_assert(_Alignof(struct YA_extra_packed) == 1, "");
_Static_assert(sizeof(struct YA_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct YA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_size) == 3, "");
_Static_assert(_Alignof(struct YA_extra_size) == 1, "");
_Static_assert(sizeof(YB) == 2, "");
_Static_assert(_Alignof(YB) == 1, "");
_Static_assert(sizeof(struct YB_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct YB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_packed) == 2, "");
_Static_assert(_Alignof(struct YB_extra_packed) == 1, "");
_Static_assert(sizeof(struct YB_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct YB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_size) == 4, "");
_Static_assert(_Alignof(struct YB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YB,b) == 8, "");
#endif
_Static_assert(sizeof(YC) == 1, "");
_Static_assert(_Alignof(YC) == 1, "");
_Static_assert(sizeof(struct YC_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct YC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_packed) == 1, "");
_Static_assert(_Alignof(struct YC_extra_packed) == 1, "");
_Static_assert(sizeof(struct YC_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct YC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_size) == 3, "");
_Static_assert(_Alignof(struct YC_extra_size) == 1, "");
_Static_assert(sizeof(YD) == 2, "");
_Static_assert(_Alignof(YD) == 1, "");
_Static_assert(sizeof(struct YD_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct YD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_packed) == 2, "");
_Static_assert(_Alignof(struct YD_extra_packed) == 1, "");
_Static_assert(sizeof(struct YD_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct YD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_size) == 4, "");
_Static_assert(_Alignof(struct YD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YD,b) == 8, "");
#endif
_Static_assert(sizeof(YE) == 1, "");
_Static_assert(_Alignof(YE) == 1, "");
_Static_assert(sizeof(struct YE_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct YE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_packed) == 1, "");
_Static_assert(_Alignof(struct YE_extra_packed) == 1, "");
_Static_assert(sizeof(struct YE_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct YE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_size) == 3, "");
_Static_assert(_Alignof(struct YE_extra_size) == 1, "");
_Static_assert(sizeof(YF) == 2, "");
_Static_assert(_Alignof(YF) == 1, "");
_Static_assert(sizeof(struct YF_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct YF_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_packed) == 2, "");
_Static_assert(_Alignof(struct YF_extra_packed) == 1, "");
_Static_assert(sizeof(struct YF_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct YF_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_size) == 4, "");
_Static_assert(_Alignof(struct YF_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YF,b) == 8, "");
#endif
_Static_assert(sizeof(D0) == 16, "");
_Static_assert(_Alignof(D0) == 16, "");
_Static_assert(sizeof(struct D0_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D0_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D0_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D0_extra_packed) == 1, "");
_Static_assert(sizeof(struct D0_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D0_extra_size) == 18, "");
_Static_assert(_Alignof(struct D0_extra_size) == 1, "");
_Static_assert(sizeof(RB0) == 8, "");
_Static_assert(_Alignof(RB0) == 8, "");
_Static_assert(sizeof(struct RB0_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct RB0_extra_alignment) == 8, "");
_Static_assert(sizeof(struct RB0_extra_packed) == 8, "");
_Static_assert(_Alignof(struct RB0_extra_packed) == 1, "");
_Static_assert(sizeof(struct RB0_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct RB0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RB0_extra_size) == 10, "");
_Static_assert(_Alignof(struct RB0_extra_size) == 1, "");
_Static_assert(sizeof(RC) == 2, "");
_Static_assert(_Alignof(RC) == 1, "");
_Static_assert(sizeof(struct RC_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_packed) == 2, "");
_Static_assert(_Alignof(struct RC_extra_packed) == 1, "");
_Static_assert(sizeof(struct RC_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct RC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_size) == 4, "");
_Static_assert(_Alignof(struct RC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RC,c) == 8, "");
#endif
_Static_assert(sizeof(RE) == 3, "");
_Static_assert(_Alignof(RE) == 1, "");
_Static_assert(sizeof(struct RE_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_packed) == 3, "");
_Static_assert(_Alignof(struct RE_extra_packed) == 1, "");
_Static_assert(sizeof(struct RE_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct RE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_size) == 5, "");
_Static_assert(_Alignof(struct RE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RE,c) == 8, "");
#endif
_Static_assert(sizeof(PA) == 4, "");
_Static_assert(_Alignof(PA) == 4, "");
_Static_assert(sizeof(struct PA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct PA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct PA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PA_extra_packed) == 1, "");
_Static_assert(sizeof(struct PA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PA_extra_size) == 6, "");
_Static_assert(_Alignof(struct PA_extra_size) == 1, "");
_Static_assert(sizeof(PB) == 4, "");
_Static_assert(_Alignof(PB) == 8, "");
_Static_assert(sizeof(struct PB_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PB_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PB_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PB_extra_packed) == 1, "");
_Static_assert(sizeof(struct PB_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PB_extra_size) == 6, "");
_Static_assert(_Alignof(struct PB_extra_size) == 1, "");
_Static_assert(sizeof(PC) == 5, "");
_Static_assert(_Alignof(PC) == 1, "");
_Static_assert(sizeof(struct PC_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PC_extra_packed) == 1, "");
_Static_assert(sizeof(struct PC_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_size) == 7, "");
_Static_assert(_Alignof(struct PC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PC,x) == 8, "");
#endif
_Static_assert(sizeof(PD) == 4, "");
_Static_assert(_Alignof(PD) == 8, "");
_Static_assert(sizeof(struct PD_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PD_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PD_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PD_extra_packed) == 1, "");
_Static_assert(sizeof(struct PD_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PD_extra_size) == 6, "");
_Static_assert(_Alignof(struct PD_extra_size) == 1, "");
_Static_assert(sizeof(PE) == 5, "");
_Static_assert(_Alignof(PE) == 1, "");
_Static_assert(sizeof(struct PE_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_packed) == 5, "");
_Static_assert(_Alignof(struct PE_extra_packed) == 1, "");
_Static_assert(sizeof(struct PE_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct PE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_size) == 7, "");
_Static_assert(_Alignof(struct PE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PE,x) == 8, "");
#endif
_Static_assert(sizeof(QA) == 2, "");
_Static_assert(_Alignof(QA) == 2, "");
_Static_assert(sizeof(struct QA_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct QA_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QA_extra_packed) == 2, "");
_Static_assert(_Alignof(struct QA_extra_packed) == 1, "");
_Static_assert(sizeof(struct QA_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct QA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QA_extra_size) == 4, "");
_Static_assert(_Alignof(struct QA_extra_size) == 1, "");
_Static_assert(sizeof(QB) == 3, "");
_Static_assert(_Alignof(QB) == 1, "");
_Static_assert(sizeof(struct QB_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct QB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_packed) == 3, "");
_Static_assert(_Alignof(struct QB_extra_packed) == 1, "");
_Static_assert(sizeof(struct QB_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct QB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_size) == 5, "");
_Static_assert(_Alignof(struct QB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QB,b) == 8, "");
#endif
_Static_assert(sizeof(QC) == 4, "");
_Static_assert(_Alignof(QC) == 2, "");
_Static_assert(sizeof(struct QC_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct QC_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QC_extra_packed) == 4, "");
_Static_assert(_Alignof(struct QC_extra_packed) == 1, "");
_Static_assert(sizeof(struct QC_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct QC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QC_extra_size) == 6, "");
_Static_assert(_Alignof(struct QC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QC,b) == 16, "");
#endif
_Static_assert(sizeof(QD) == 2, "");
_Static_assert(_Alignof(QD) == 2, "");
_Static_assert(sizeof(struct QD_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct QD_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QD_extra_packed) == 2, "");
_Static_assert(_Alignof(struct QD_extra_packed) == 1, "");
_Static_assert(sizeof(struct QD_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct QD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_size) == 4, "");
_Static_assert(_Alignof(struct QD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QD,b) == 8, "");
#endif
_Static_assert(sizeof(EmptyAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAlignedLongLongMemb) == 0, "");
_Static_assert(_Alignof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 0, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 2, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 1, "");
// MAPPING|TEN|thumb-baseline-windows-msvc:Msvc|END
// repr targets Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc")
#elif defined(TEN)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(X) == 16, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 20, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 18, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,b) == 64, "");
_Static_assert(__builtin_bitoffsetof(X,c) == 80, "");
#endif
_Static_assert(sizeof(YA) == 16, "");
_Static_assert(_Alignof(YA) == 32, "");
_Static_assert(sizeof(struct YA_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct YA_extra_alignment) == 32, "");
_Static_assert(sizeof(struct YA_extra_packed) == 16, "");
_Static_assert(_Alignof(struct YA_extra_packed) == 1, "");
_Static_assert(sizeof(struct YA_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct YA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YA_extra_size) == 18, "");
_Static_assert(_Alignof(struct YA_extra_size) == 1, "");
_Static_assert(sizeof(YB) == 17, "");
_Static_assert(_Alignof(YB) == 1, "");
_Static_assert(sizeof(struct YB_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct YB_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_packed) == 17, "");
_Static_assert(_Alignof(struct YB_extra_packed) == 1, "");
_Static_assert(sizeof(struct YB_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct YB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YB_extra_size) == 19, "");
_Static_assert(_Alignof(struct YB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YB,b) == 8, "");
#endif
_Static_assert(sizeof(YC) == 8, "");
_Static_assert(_Alignof(YC) == 32, "");
_Static_assert(sizeof(struct YC_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct YC_extra_alignment) == 32, "");
_Static_assert(sizeof(struct YC_extra_packed) == 8, "");
_Static_assert(_Alignof(struct YC_extra_packed) == 1, "");
_Static_assert(sizeof(struct YC_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct YC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YC_extra_size) == 10, "");
_Static_assert(_Alignof(struct YC_extra_size) == 1, "");
_Static_assert(sizeof(YD) == 9, "");
_Static_assert(_Alignof(YD) == 1, "");
_Static_assert(sizeof(struct YD_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_packed) == 9, "");
_Static_assert(_Alignof(struct YD_extra_packed) == 1, "");
_Static_assert(sizeof(struct YD_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct YD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YD_extra_size) == 11, "");
_Static_assert(_Alignof(struct YD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YD,b) == 8, "");
#endif
_Static_assert(sizeof(YE) == 4, "");
_Static_assert(_Alignof(YE) == 32, "");
_Static_assert(sizeof(struct YE_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct YE_extra_alignment) == 32, "");
_Static_assert(sizeof(struct YE_extra_packed) == 4, "");
_Static_assert(_Alignof(struct YE_extra_packed) == 1, "");
_Static_assert(sizeof(struct YE_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct YE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YE_extra_size) == 6, "");
_Static_assert(_Alignof(struct YE_extra_size) == 1, "");
_Static_assert(sizeof(YF) == 5, "");
_Static_assert(_Alignof(YF) == 1, "");
_Static_assert(sizeof(struct YF_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_packed) == 5, "");
_Static_assert(_Alignof(struct YF_extra_packed) == 1, "");
_Static_assert(sizeof(struct YF_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct YF_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct YF_extra_size) == 7, "");
_Static_assert(_Alignof(struct YF_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(YF,b) == 8, "");
#endif
_Static_assert(sizeof(D0) == 16, "");
_Static_assert(_Alignof(D0) == 16, "");
_Static_assert(sizeof(struct D0_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D0_extra_alignment) == 16, "");
_Static_assert(sizeof(struct D0_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D0_extra_packed) == 1, "");
_Static_assert(sizeof(struct D0_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D0_extra_size) == 18, "");
_Static_assert(_Alignof(struct D0_extra_size) == 1, "");
_Static_assert(sizeof(RB0) == 8, "");
_Static_assert(_Alignof(RB0) == 1024, "");
_Static_assert(sizeof(struct RB0_extra_alignment) == 2048, "");
_Static_assert(_Alignof(struct RB0_extra_alignment) == 1024, "");
_Static_assert(sizeof(struct RB0_extra_packed) == 8, "");
_Static_assert(_Alignof(struct RB0_extra_packed) == 1, "");
_Static_assert(sizeof(struct RB0_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct RB0_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RB0_extra_size) == 10, "");
_Static_assert(_Alignof(struct RB0_extra_size) == 1, "");
_Static_assert(sizeof(RC) == 1028, "");
_Static_assert(_Alignof(RC) == 1024, "");
_Static_assert(sizeof(struct RC_extra_alignment) == 3072, "");
_Static_assert(_Alignof(struct RC_extra_alignment) == 1024, "");
_Static_assert(sizeof(struct RC_extra_packed) == 1028, "");
_Static_assert(_Alignof(struct RC_extra_packed) == 1, "");
_Static_assert(sizeof(struct RC_extra_required_alignment) == 1029, "");
_Static_assert(_Alignof(struct RC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RC_extra_size) == 1030, "");
_Static_assert(_Alignof(struct RC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RC,c) == 8192, "");
#endif
_Static_assert(sizeof(RE) == 1029, "");
_Static_assert(_Alignof(RE) == 1, "");
_Static_assert(sizeof(struct RE_extra_alignment) == 1030, "");
_Static_assert(_Alignof(struct RE_extra_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_packed) == 1029, "");
_Static_assert(_Alignof(struct RE_extra_packed) == 1, "");
_Static_assert(sizeof(struct RE_extra_required_alignment) == 1030, "");
_Static_assert(_Alignof(struct RE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct RE_extra_size) == 1031, "");
_Static_assert(_Alignof(struct RE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(RE,c) == 8, "");
#endif
_Static_assert(sizeof(PA) == 4, "");
_Static_assert(_Alignof(PA) == 4, "");
_Static_assert(sizeof(struct PA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct PA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct PA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PA_extra_packed) == 1, "");
_Static_assert(sizeof(struct PA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PA_extra_size) == 6, "");
_Static_assert(_Alignof(struct PA_extra_size) == 1, "");
_Static_assert(sizeof(PB) == 4, "");
_Static_assert(_Alignof(PB) == 8, "");
_Static_assert(sizeof(struct PB_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PB_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PB_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PB_extra_packed) == 1, "");
_Static_assert(sizeof(struct PB_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PB_extra_size) == 6, "");
_Static_assert(_Alignof(struct PB_extra_size) == 1, "");
_Static_assert(sizeof(PC) == 16, "");
_Static_assert(_Alignof(PC) == 8, "");
_Static_assert(sizeof(struct PC_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct PC_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PC_extra_packed) == 16, "");
_Static_assert(_Alignof(struct PC_extra_packed) == 1, "");
_Static_assert(sizeof(struct PC_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct PC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PC_extra_size) == 18, "");
_Static_assert(_Alignof(struct PC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PC,x) == 64, "");
#endif
_Static_assert(sizeof(PD) == 4, "");
_Static_assert(_Alignof(PD) == 8, "");
_Static_assert(sizeof(struct PD_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct PD_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PD_extra_packed) == 4, "");
_Static_assert(_Alignof(struct PD_extra_packed) == 1, "");
_Static_assert(sizeof(struct PD_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct PD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PD_extra_size) == 6, "");
_Static_assert(_Alignof(struct PD_extra_size) == 1, "");
_Static_assert(sizeof(PE) == 16, "");
_Static_assert(_Alignof(PE) == 8, "");
_Static_assert(sizeof(struct PE_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct PE_extra_alignment) == 8, "");
_Static_assert(sizeof(struct PE_extra_packed) == 16, "");
_Static_assert(_Alignof(struct PE_extra_packed) == 1, "");
_Static_assert(sizeof(struct PE_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct PE_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct PE_extra_size) == 18, "");
_Static_assert(_Alignof(struct PE_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(PE,x) == 64, "");
#endif
_Static_assert(sizeof(QA) == 4, "");
_Static_assert(_Alignof(QA) == 4, "");
_Static_assert(sizeof(struct QA_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QA_extra_alignment) == 4, "");
_Static_assert(sizeof(struct QA_extra_packed) == 4, "");
_Static_assert(_Alignof(struct QA_extra_packed) == 1, "");
_Static_assert(sizeof(struct QA_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct QA_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QA_extra_size) == 6, "");
_Static_assert(_Alignof(struct QA_extra_size) == 1, "");
_Static_assert(sizeof(QB) == 6, "");
_Static_assert(_Alignof(QB) == 2, "");
_Static_assert(sizeof(struct QB_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct QB_extra_alignment) == 2, "");
_Static_assert(sizeof(struct QB_extra_packed) == 6, "");
_Static_assert(_Alignof(struct QB_extra_packed) == 1, "");
_Static_assert(sizeof(struct QB_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct QB_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QB_extra_size) == 8, "");
_Static_assert(_Alignof(struct QB_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QB,b) == 16, "");
#endif
_Static_assert(sizeof(QC) == 8, "");
_Static_assert(_Alignof(QC) == 4, "");
_Static_assert(sizeof(struct QC_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct QC_extra_alignment) == 4, "");
_Static_assert(sizeof(struct QC_extra_packed) == 8, "");
_Static_assert(_Alignof(struct QC_extra_packed) == 1, "");
_Static_assert(sizeof(struct QC_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct QC_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QC_extra_size) == 10, "");
_Static_assert(_Alignof(struct QC_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QC,b) == 32, "");
#endif
_Static_assert(sizeof(QD) == 8, "");
_Static_assert(_Alignof(QD) == 4, "");
_Static_assert(sizeof(struct QD_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct QD_extra_alignment) == 4, "");
_Static_assert(sizeof(struct QD_extra_packed) == 8, "");
_Static_assert(_Alignof(struct QD_extra_packed) == 1, "");
_Static_assert(sizeof(struct QD_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct QD_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct QD_extra_size) == 10, "");
_Static_assert(_Alignof(struct QD_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(QD,b) == 32, "");
#endif
_Static_assert(sizeof(EmptyAlignedLongLongMemb) == 4, "");
_Static_assert(_Alignof(EmptyAlignedLongLongMemb) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_packed) == 4, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyAlignedLongLongMemb_extra_size) == 6, "");
_Static_assert(_Alignof(struct EmptyAlignedLongLongMemb_extra_size) == 1, "");
_Static_assert(sizeof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(_Alignof(EmptyPackedAlignedLongLongMemb) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_alignment) == 4, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 4, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_packed) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 6, "");
_Static_assert(_Alignof(struct EmptyPackedAlignedLongLongMemb_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0041_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef union {
int a:1;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef union {
#ifdef MSVC
__declspec(align(8)) int a:1;
#else
int a:1 __attribute__((aligned(8)));
#endif
} B;
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
typedef union {
#ifdef MSVC
__declspec(align(8)) int:0;
#else
int:0 __attribute__((aligned(8)));
#endif
} C;
C var9;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var10;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var11;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var12;
typedef union {
char c;
#ifdef MSVC
__declspec(align(8)) int:0;
#else
int:0 __attribute__((aligned(8)));
#endif
} D;
D var13;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var14;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var15;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var16;
typedef union {
char c;
#ifdef MSVC
__declspec(align(8)) int:0;
__declspec(align(8)) int:0;
#else
int:0 __attribute__((aligned(8)));
int:0 __attribute__((aligned(8)));
#endif
} E;
E var17;
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var18;
#pragma pack(1)
struct E_extra_packed {
#ifdef MSVC
char a[sizeof(E)];
#else
E a;
#endif
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var19;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var20;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 0, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 0, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 2, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(E) == 1, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 3, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 0, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 0, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 2, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|THREE|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(THREE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(E) == 1, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 3, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FOUR|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 0, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 0, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 2, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|FIVE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 0, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 0, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 2, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(E) == 8, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 8, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 10, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
// MAPPING|SIX|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SIX)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
_Static_assert(sizeof(C) == 0, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 1, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 0, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 1, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 2, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
_Static_assert(sizeof(D) == 1, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 1, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 3, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
_Static_assert(sizeof(E) == 1, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 1, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 3, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0005_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(8)) typedef int Int;
#else
typedef int Int __attribute__((aligned(8)));
#endif
Int var1;
struct Int_extra_alignment {
char a;
Int b;
};
struct Int_extra_alignment var2;
#pragma pack(1)
struct Int_extra_packed {
#ifdef MSVC
char a[sizeof(Int)];
#else
Int a;
#endif
};
#pragma pack()
struct Int_extra_required_alignment {
char a;
struct Int_extra_packed b;
};
struct Int_extra_required_alignment var3;
struct Int_extra_size {
char a[sizeof(Int)+1];
char b;
};
struct Int_extra_size var4;
typedef struct {
Int i:1;
} X;
X var5;
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var6;
#pragma pack(1)
struct X_extra_packed {
#ifdef MSVC
char a[sizeof(X)];
#else
X a;
#endif
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var7;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var8;
#pragma pack(1)
typedef struct {
X x;
} Y;
Y var9;
#pragma pack()
struct Y_extra_alignment {
char a;
Y b;
};
struct Y_extra_alignment var10;
#pragma pack(1)
struct Y_extra_packed {
#ifdef MSVC
char a[sizeof(Y)];
#else
Y a;
#endif
};
#pragma pack()
struct Y_extra_required_alignment {
char a;
struct Y_extra_packed b;
};
struct Y_extra_required_alignment var11;
struct Y_extra_size {
char a[sizeof(Y)+1];
char b;
};
struct Y_extra_size var12;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(Int) == 4, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 6, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 8, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 8, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 10, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 8, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(Int) == 4, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 6, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 8, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 8, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 10, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 8, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(THREE)
_Static_assert(sizeof(Int) == 4, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 6, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 1, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 3, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 1, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(Int) == 2, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 4, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 1, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 3, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 1, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(Int) == 2, "");
_Static_assert(_Alignof(Int) == 8, "");
_Static_assert(sizeof(struct Int_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Int_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Int_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Int_extra_packed) == 1, "");
_Static_assert(sizeof(struct Int_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Int_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Int_extra_size) == 4, "");
_Static_assert(_Alignof(struct Int_extra_size) == 1, "");
_Static_assert(sizeof(X) == 8, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 8, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 10, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 8, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0042_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(16)) typedef struct {
#else
typedef struct {
#endif
int x;
#ifdef MSVC
} AlignedStruct;
#else
} __attribute__((aligned(16))) AlignedStruct;
#endif
AlignedStruct var1;
struct AlignedStruct_extra_alignment {
char a;
AlignedStruct b;
};
struct AlignedStruct_extra_alignment var2;
#pragma pack(1)
struct AlignedStruct_extra_packed {
#ifdef MSVC
char a[sizeof(AlignedStruct)];
#else
AlignedStruct a;
#endif
};
#pragma pack()
struct AlignedStruct_extra_required_alignment {
char a;
struct AlignedStruct_extra_packed b;
};
struct AlignedStruct_extra_required_alignment var3;
struct AlignedStruct_extra_size {
char a[sizeof(AlignedStruct)+1];
char b;
};
struct AlignedStruct_extra_size var4;
#ifdef MSVC
__declspec(align(16)) typedef int AlignedInt;
#else
typedef int AlignedInt __attribute__((aligned(16)));
#endif
AlignedInt var5;
struct AlignedInt_extra_alignment {
char a;
AlignedInt b;
};
struct AlignedInt_extra_alignment var6;
#pragma pack(1)
struct AlignedInt_extra_packed {
#ifdef MSVC
char a[sizeof(AlignedInt)];
#else
AlignedInt a;
#endif
};
#pragma pack()
struct AlignedInt_extra_required_alignment {
char a;
struct AlignedInt_extra_packed b;
};
struct AlignedInt_extra_required_alignment var7;
struct AlignedInt_extra_size {
char a[sizeof(AlignedInt)+1];
char b;
};
struct AlignedInt_extra_size var8;
typedef AlignedStruct unnamed_type_9[1];
unnamed_type_9 var10;
struct unnamed_type_9_extra_alignment {
char a;
unnamed_type_9 b;
};
struct unnamed_type_9_extra_alignment var11;
#pragma pack(1)
struct unnamed_type_9_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_9)];
#else
unnamed_type_9 a;
#endif
};
#pragma pack()
struct unnamed_type_9_extra_required_alignment {
char a;
struct unnamed_type_9_extra_packed b;
};
struct unnamed_type_9_extra_required_alignment var12;
struct unnamed_type_9_extra_size {
char a[sizeof(unnamed_type_9)+1];
char b;
};
struct unnamed_type_9_extra_size var13;
#pragma pack(2)
typedef struct {
unnamed_type_9 a;
} A;
A var14;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var15;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var16;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var17;
typedef AlignedInt unnamed_type_18[1];
unnamed_type_18 var19;
struct unnamed_type_18_extra_alignment {
char a;
unnamed_type_18 b;
};
struct unnamed_type_18_extra_alignment var20;
#pragma pack(1)
struct unnamed_type_18_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_18)];
#else
unnamed_type_18 a;
#endif
};
#pragma pack()
struct unnamed_type_18_extra_required_alignment {
char a;
struct unnamed_type_18_extra_packed b;
};
struct unnamed_type_18_extra_required_alignment var21;
struct unnamed_type_18_extra_size {
char a[sizeof(unnamed_type_18)+1];
char b;
};
struct unnamed_type_18_extra_size var22;
#pragma pack(2)
typedef struct {
char b;
unnamed_type_18 a;
} B;
B var23;
#pragma pack()
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var24;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var25;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var26;
#ifdef MSVC
typedef AlignedInt unnamed_type_27[];
#else
typedef AlignedInt unnamed_type_27[0];
#endif
unnamed_type_27 var28;
struct unnamed_type_27_extra_alignment {
char a;
unnamed_type_27 b;
};
struct unnamed_type_27_extra_alignment var29;
#pragma pack(1)
struct unnamed_type_27_extra_packed {
#ifdef MSVC
char a[sizeof(unnamed_type_27)];
#else
unnamed_type_27 a;
#endif
};
#pragma pack()
struct unnamed_type_27_extra_required_alignment {
char a;
struct unnamed_type_27_extra_packed b;
};
struct unnamed_type_27_extra_required_alignment var30;
struct unnamed_type_27_extra_size {
char a[sizeof(unnamed_type_27)+1];
char b;
};
struct unnamed_type_27_extra_size var31;
#pragma pack(2)
typedef struct {
char c;
unnamed_type_27 a;
} C;
C var32;
#pragma pack()
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var33;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var34;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var35;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-other-none:Clang|powerpc64-ppc64-freebsd-gnu:Clang|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv64-baseline_rv64-other-eabi:Clang|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownNone|Some("mipsel-mips32-other-none") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(AlignedStruct) == 16, "");
_Static_assert(_Alignof(AlignedStruct) == 16, "");
_Static_assert(sizeof(struct AlignedStruct_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_alignment) == 16, "");
_Static_assert(sizeof(struct AlignedStruct_extra_packed) == 16, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_packed) == 1, "");
_Static_assert(sizeof(struct AlignedStruct_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct AlignedStruct_extra_size) == 18, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_size) == 1, "");
_Static_assert(sizeof(AlignedInt) == 4, "");
_Static_assert(_Alignof(AlignedInt) == 16, "");
_Static_assert(sizeof(struct AlignedInt_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct AlignedInt_extra_alignment) == 16, "");
_Static_assert(sizeof(struct AlignedInt_extra_packed) == 4, "");
_Static_assert(_Alignof(struct AlignedInt_extra_packed) == 1, "");
_Static_assert(sizeof(struct AlignedInt_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct AlignedInt_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct AlignedInt_extra_size) == 6, "");
_Static_assert(_Alignof(struct AlignedInt_extra_size) == 1, "");
_Static_assert(sizeof(A) == 16, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 18, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 18, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 20, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 18, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 19, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 20, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,a) == 16, "");
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,a) == 16, "");
#endif
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(AlignedStruct) == 16, "");
_Static_assert(_Alignof(AlignedStruct) == 16, "");
_Static_assert(sizeof(struct AlignedStruct_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_alignment) == 16, "");
_Static_assert(sizeof(struct AlignedStruct_extra_packed) == 16, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_packed) == 1, "");
_Static_assert(sizeof(struct AlignedStruct_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct AlignedStruct_extra_size) == 18, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_size) == 1, "");
_Static_assert(sizeof(AlignedInt) == 4, "");
_Static_assert(_Alignof(AlignedInt) == 16, "");
_Static_assert(sizeof(struct AlignedInt_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct AlignedInt_extra_alignment) == 16, "");
_Static_assert(sizeof(struct AlignedInt_extra_packed) == 4, "");
_Static_assert(_Alignof(struct AlignedInt_extra_packed) == 1, "");
_Static_assert(sizeof(struct AlignedInt_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct AlignedInt_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct AlignedInt_extra_size) == 6, "");
_Static_assert(_Alignof(struct AlignedInt_extra_size) == 1, "");
_Static_assert(sizeof(A) == 16, "");
_Static_assert(_Alignof(A) == 16, "");
_Static_assert(sizeof(struct A_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 18, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 32, "");
_Static_assert(_Alignof(B) == 16, "");
_Static_assert(sizeof(struct B_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 34, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,a) == 128, "");
#endif
_Static_assert(sizeof(C) == 16, "");
_Static_assert(_Alignof(C) == 16, "");
_Static_assert(sizeof(struct C_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 16, "");
_Static_assert(sizeof(struct C_extra_packed) == 16, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 18, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,a) == 128, "");
#endif
// MAPPING|THREE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(AlignedStruct) == 16, "");
_Static_assert(_Alignof(AlignedStruct) == 16, "");
_Static_assert(sizeof(struct AlignedStruct_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_alignment) == 16, "");
_Static_assert(sizeof(struct AlignedStruct_extra_packed) == 16, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_packed) == 1, "");
_Static_assert(sizeof(struct AlignedStruct_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct AlignedStruct_extra_size) == 18, "");
_Static_assert(_Alignof(struct AlignedStruct_extra_size) == 1, "");
_Static_assert(sizeof(AlignedInt) == 2, "");
_Static_assert(_Alignof(AlignedInt) == 16, "");
_Static_assert(sizeof(struct AlignedInt_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct AlignedInt_extra_alignment) == 16, "");
_Static_assert(sizeof(struct AlignedInt_extra_packed) == 2, "");
_Static_assert(_Alignof(struct AlignedInt_extra_packed) == 1, "");
_Static_assert(sizeof(struct AlignedInt_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct AlignedInt_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct AlignedInt_extra_size) == 4, "");
_Static_assert(_Alignof(struct AlignedInt_extra_size) == 1, "");
_Static_assert(sizeof(A) == 16, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 18, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 18, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 20, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 18, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 19, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 20, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,a) == 16, "");
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 2, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 2, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,a) == 16, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0086_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c;
int i __attribute__((aligned(32)));
} A000;
A000 var1;
struct A000_extra_alignment {
char a;
A000 b;
};
struct A000_extra_alignment var2;
#pragma pack(1)
struct A000_extra_packed {
A000 a;
};
#pragma pack()
struct A000_extra_required_alignment {
char a;
struct A000_extra_packed b;
};
struct A000_extra_required_alignment var3;
struct A000_extra_size {
char a[sizeof(A000)+1];
char b;
};
struct A000_extra_size var4;
typedef struct {
char c;
int i __attribute__((aligned(32)));
} __attribute__((packed)) A001;
A001 var5;
struct A001_extra_alignment {
char a;
A001 b;
};
struct A001_extra_alignment var6;
#pragma pack(1)
struct A001_extra_packed {
A001 a;
};
#pragma pack()
struct A001_extra_required_alignment {
char a;
struct A001_extra_packed b;
};
struct A001_extra_required_alignment var7;
struct A001_extra_size {
char a[sizeof(A001)+1];
char b;
};
struct A001_extra_size var8;
typedef struct {
char c;
int i __attribute__((aligned(32))) __attribute__((packed));
} A002;
A002 var9;
struct A002_extra_alignment {
char a;
A002 b;
};
struct A002_extra_alignment var10;
#pragma pack(1)
struct A002_extra_packed {
A002 a;
};
#pragma pack()
struct A002_extra_required_alignment {
char a;
struct A002_extra_packed b;
};
struct A002_extra_required_alignment var11;
struct A002_extra_size {
char a[sizeof(A002)+1];
char b;
};
struct A002_extra_size var12;
typedef struct {
char c;
int i __attribute__((aligned(32))) __attribute__((packed));
} __attribute__((packed)) A003;
A003 var13;
struct A003_extra_alignment {
char a;
A003 b;
};
struct A003_extra_alignment var14;
#pragma pack(1)
struct A003_extra_packed {
A003 a;
};
#pragma pack()
struct A003_extra_required_alignment {
char a;
struct A003_extra_packed b;
};
struct A003_extra_required_alignment var15;
struct A003_extra_size {
char a[sizeof(A003)+1];
char b;
};
struct A003_extra_size var16;
typedef int A004 __attribute__((aligned(16)));
A004 var17;
struct A004_extra_alignment {
char a;
A004 b;
};
struct A004_extra_alignment var18;
#pragma pack(1)
struct A004_extra_packed {
A004 a;
};
#pragma pack()
struct A004_extra_required_alignment {
char a;
struct A004_extra_packed b;
};
struct A004_extra_required_alignment var19;
struct A004_extra_size {
char a[sizeof(A004)+1];
char b;
};
struct A004_extra_size var20;
typedef struct {
char c;
A004 i __attribute__((aligned(32)));
} A005;
A005 var21;
struct A005_extra_alignment {
char a;
A005 b;
};
struct A005_extra_alignment var22;
#pragma pack(1)
struct A005_extra_packed {
A005 a;
};
#pragma pack()
struct A005_extra_required_alignment {
char a;
struct A005_extra_packed b;
};
struct A005_extra_required_alignment var23;
struct A005_extra_size {
char a[sizeof(A005)+1];
char b;
};
struct A005_extra_size var24;
typedef struct {
char c;
A004 i __attribute__((aligned(32)));
} __attribute__((packed)) A006;
A006 var25;
struct A006_extra_alignment {
char a;
A006 b;
};
struct A006_extra_alignment var26;
#pragma pack(1)
struct A006_extra_packed {
A006 a;
};
#pragma pack()
struct A006_extra_required_alignment {
char a;
struct A006_extra_packed b;
};
struct A006_extra_required_alignment var27;
struct A006_extra_size {
char a[sizeof(A006)+1];
char b;
};
struct A006_extra_size var28;
typedef struct {
char c;
A004 i __attribute__((aligned(32))) __attribute__((packed));
} A007;
A007 var29;
struct A007_extra_alignment {
char a;
A007 b;
};
struct A007_extra_alignment var30;
#pragma pack(1)
struct A007_extra_packed {
A007 a;
};
#pragma pack()
struct A007_extra_required_alignment {
char a;
struct A007_extra_packed b;
};
struct A007_extra_required_alignment var31;
struct A007_extra_size {
char a[sizeof(A007)+1];
char b;
};
struct A007_extra_size var32;
typedef struct {
char c;
A004 i __attribute__((aligned(32))) __attribute__((packed));
} __attribute__((packed)) A008;
A008 var33;
struct A008_extra_alignment {
char a;
A008 b;
};
struct A008_extra_alignment var34;
#pragma pack(1)
struct A008_extra_packed {
A008 a;
};
#pragma pack()
struct A008_extra_required_alignment {
char a;
struct A008_extra_packed b;
};
struct A008_extra_required_alignment var35;
struct A008_extra_size {
char a[sizeof(A008)+1];
char b;
};
struct A008_extra_size var36;
#pragma pack(2)
typedef struct {
char c;
int i __attribute__((aligned(32)));
} A100;
A100 var37;
#pragma pack()
struct A100_extra_alignment {
char a;
A100 b;
};
struct A100_extra_alignment var38;
#pragma pack(1)
struct A100_extra_packed {
A100 a;
};
#pragma pack()
struct A100_extra_required_alignment {
char a;
struct A100_extra_packed b;
};
struct A100_extra_required_alignment var39;
struct A100_extra_size {
char a[sizeof(A100)+1];
char b;
};
struct A100_extra_size var40;
#pragma pack(2)
typedef struct {
char c;
int i __attribute__((aligned(32)));
} __attribute__((packed)) A101;
A101 var41;
#pragma pack()
struct A101_extra_alignment {
char a;
A101 b;
};
struct A101_extra_alignment var42;
#pragma pack(1)
struct A101_extra_packed {
A101 a;
};
#pragma pack()
struct A101_extra_required_alignment {
char a;
struct A101_extra_packed b;
};
struct A101_extra_required_alignment var43;
struct A101_extra_size {
char a[sizeof(A101)+1];
char b;
};
struct A101_extra_size var44;
#pragma pack(2)
typedef struct {
char c;
int i __attribute__((aligned(32))) __attribute__((packed));
} A102;
A102 var45;
#pragma pack()
struct A102_extra_alignment {
char a;
A102 b;
};
struct A102_extra_alignment var46;
#pragma pack(1)
struct A102_extra_packed {
A102 a;
};
#pragma pack()
struct A102_extra_required_alignment {
char a;
struct A102_extra_packed b;
};
struct A102_extra_required_alignment var47;
struct A102_extra_size {
char a[sizeof(A102)+1];
char b;
};
struct A102_extra_size var48;
#pragma pack(2)
typedef struct {
char c;
int i __attribute__((aligned(32))) __attribute__((packed));
} __attribute__((packed)) A103;
A103 var49;
#pragma pack()
struct A103_extra_alignment {
char a;
A103 b;
};
struct A103_extra_alignment var50;
#pragma pack(1)
struct A103_extra_packed {
A103 a;
};
#pragma pack()
struct A103_extra_required_alignment {
char a;
struct A103_extra_packed b;
};
struct A103_extra_required_alignment var51;
struct A103_extra_size {
char a[sizeof(A103)+1];
char b;
};
struct A103_extra_size var52;
typedef int A104 __attribute__((aligned(16)));
A104 var53;
struct A104_extra_alignment {
char a;
A104 b;
};
struct A104_extra_alignment var54;
#pragma pack(1)
struct A104_extra_packed {
A104 a;
};
#pragma pack()
struct A104_extra_required_alignment {
char a;
struct A104_extra_packed b;
};
struct A104_extra_required_alignment var55;
struct A104_extra_size {
char a[sizeof(A104)+1];
char b;
};
struct A104_extra_size var56;
#pragma pack(2)
typedef struct {
char c;
A104 i __attribute__((aligned(32)));
} A105;
A105 var57;
#pragma pack()
struct A105_extra_alignment {
char a;
A105 b;
};
struct A105_extra_alignment var58;
#pragma pack(1)
struct A105_extra_packed {
A105 a;
};
#pragma pack()
struct A105_extra_required_alignment {
char a;
struct A105_extra_packed b;
};
struct A105_extra_required_alignment var59;
struct A105_extra_size {
char a[sizeof(A105)+1];
char b;
};
struct A105_extra_size var60;
#pragma pack(2)
typedef struct {
char c;
A104 i __attribute__((aligned(32)));
} __attribute__((packed)) A106;
A106 var61;
#pragma pack()
struct A106_extra_alignment {
char a;
A106 b;
};
struct A106_extra_alignment var62;
#pragma pack(1)
struct A106_extra_packed {
A106 a;
};
#pragma pack()
struct A106_extra_required_alignment {
char a;
struct A106_extra_packed b;
};
struct A106_extra_required_alignment var63;
struct A106_extra_size {
char a[sizeof(A106)+1];
char b;
};
struct A106_extra_size var64;
#pragma pack(2)
typedef struct {
char c;
A104 i __attribute__((aligned(32))) __attribute__((packed));
} A107;
A107 var65;
#pragma pack()
struct A107_extra_alignment {
char a;
A107 b;
};
struct A107_extra_alignment var66;
#pragma pack(1)
struct A107_extra_packed {
A107 a;
};
#pragma pack()
struct A107_extra_required_alignment {
char a;
struct A107_extra_packed b;
};
struct A107_extra_required_alignment var67;
struct A107_extra_size {
char a[sizeof(A107)+1];
char b;
};
struct A107_extra_size var68;
#pragma pack(2)
typedef struct {
char c;
A104 i __attribute__((aligned(32))) __attribute__((packed));
} __attribute__((packed)) A108;
A108 var69;
#pragma pack()
struct A108_extra_alignment {
char a;
A108 b;
};
struct A108_extra_alignment var70;
#pragma pack(1)
struct A108_extra_packed {
A108 a;
};
#pragma pack()
struct A108_extra_required_alignment {
char a;
struct A108_extra_packed b;
};
struct A108_extra_required_alignment var71;
struct A108_extra_size {
char a[sizeof(A108)+1];
char b;
};
struct A108_extra_size var72;
typedef union {
char c;
int i __attribute__((aligned(32)));
} B000;
B000 var73;
struct B000_extra_alignment {
char a;
B000 b;
};
struct B000_extra_alignment var74;
#pragma pack(1)
struct B000_extra_packed {
B000 a;
};
#pragma pack()
struct B000_extra_required_alignment {
char a;
struct B000_extra_packed b;
};
struct B000_extra_required_alignment var75;
struct B000_extra_size {
char a[sizeof(B000)+1];
char b;
};
struct B000_extra_size var76;
typedef union {
char c;
int i __attribute__((aligned(32)));
} __attribute__((packed)) B001;
B001 var77;
struct B001_extra_alignment {
char a;
B001 b;
};
struct B001_extra_alignment var78;
#pragma pack(1)
struct B001_extra_packed {
B001 a;
};
#pragma pack()
struct B001_extra_required_alignment {
char a;
struct B001_extra_packed b;
};
struct B001_extra_required_alignment var79;
struct B001_extra_size {
char a[sizeof(B001)+1];
char b;
};
struct B001_extra_size var80;
typedef union {
char c;
int i __attribute__((aligned(32))) __attribute__((packed));
} B002;
B002 var81;
struct B002_extra_alignment {
char a;
B002 b;
};
struct B002_extra_alignment var82;
#pragma pack(1)
struct B002_extra_packed {
B002 a;
};
#pragma pack()
struct B002_extra_required_alignment {
char a;
struct B002_extra_packed b;
};
struct B002_extra_required_alignment var83;
struct B002_extra_size {
char a[sizeof(B002)+1];
char b;
};
struct B002_extra_size var84;
typedef union {
char c;
int i __attribute__((aligned(32))) __attribute__((packed));
} __attribute__((packed)) B003;
B003 var85;
struct B003_extra_alignment {
char a;
B003 b;
};
struct B003_extra_alignment var86;
#pragma pack(1)
struct B003_extra_packed {
B003 a;
};
#pragma pack()
struct B003_extra_required_alignment {
char a;
struct B003_extra_packed b;
};
struct B003_extra_required_alignment var87;
struct B003_extra_size {
char a[sizeof(B003)+1];
char b;
};
struct B003_extra_size var88;
typedef int B004 __attribute__((aligned(16)));
B004 var89;
struct B004_extra_alignment {
char a;
B004 b;
};
struct B004_extra_alignment var90;
#pragma pack(1)
struct B004_extra_packed {
B004 a;
};
#pragma pack()
struct B004_extra_required_alignment {
char a;
struct B004_extra_packed b;
};
struct B004_extra_required_alignment var91;
struct B004_extra_size {
char a[sizeof(B004)+1];
char b;
};
struct B004_extra_size var92;
typedef union {
char c;
A004 i __attribute__((aligned(32)));
} B005;
B005 var93;
struct B005_extra_alignment {
char a;
B005 b;
};
struct B005_extra_alignment var94;
#pragma pack(1)
struct B005_extra_packed {
B005 a;
};
#pragma pack()
struct B005_extra_required_alignment {
char a;
struct B005_extra_packed b;
};
struct B005_extra_required_alignment var95;
struct B005_extra_size {
char a[sizeof(B005)+1];
char b;
};
struct B005_extra_size var96;
typedef union {
char c;
A004 i __attribute__((aligned(32)));
} __attribute__((packed)) B006;
B006 var97;
struct B006_extra_alignment {
char a;
B006 b;
};
struct B006_extra_alignment var98;
#pragma pack(1)
struct B006_extra_packed {
B006 a;
};
#pragma pack()
struct B006_extra_required_alignment {
char a;
struct B006_extra_packed b;
};
struct B006_extra_required_alignment var99;
struct B006_extra_size {
char a[sizeof(B006)+1];
char b;
};
struct B006_extra_size var100;
typedef union {
char c;
A004 i __attribute__((aligned(32))) __attribute__((packed));
} B007;
B007 var101;
struct B007_extra_alignment {
char a;
B007 b;
};
struct B007_extra_alignment var102;
#pragma pack(1)
struct B007_extra_packed {
B007 a;
};
#pragma pack()
struct B007_extra_required_alignment {
char a;
struct B007_extra_packed b;
};
struct B007_extra_required_alignment var103;
struct B007_extra_size {
char a[sizeof(B007)+1];
char b;
};
struct B007_extra_size var104;
typedef union {
char c;
A004 i __attribute__((aligned(32))) __attribute__((packed));
} __attribute__((packed)) B008;
B008 var105;
struct B008_extra_alignment {
char a;
B008 b;
};
struct B008_extra_alignment var106;
#pragma pack(1)
struct B008_extra_packed {
B008 a;
};
#pragma pack()
struct B008_extra_required_alignment {
char a;
struct B008_extra_packed b;
};
struct B008_extra_required_alignment var107;
struct B008_extra_size {
char a[sizeof(B008)+1];
char b;
};
struct B008_extra_size var108;
#pragma pack(2)
typedef union {
char c;
int i __attribute__((aligned(32)));
} B100;
B100 var109;
#pragma pack()
struct B100_extra_alignment {
char a;
B100 b;
};
struct B100_extra_alignment var110;
#pragma pack(1)
struct B100_extra_packed {
B100 a;
};
#pragma pack()
struct B100_extra_required_alignment {
char a;
struct B100_extra_packed b;
};
struct B100_extra_required_alignment var111;
struct B100_extra_size {
char a[sizeof(B100)+1];
char b;
};
struct B100_extra_size var112;
#pragma pack(2)
typedef union {
char c;
int i __attribute__((aligned(32)));
} __attribute__((packed)) B101;
B101 var113;
#pragma pack()
struct B101_extra_alignment {
char a;
B101 b;
};
struct B101_extra_alignment var114;
#pragma pack(1)
struct B101_extra_packed {
B101 a;
};
#pragma pack()
struct B101_extra_required_alignment {
char a;
struct B101_extra_packed b;
};
struct B101_extra_required_alignment var115;
struct B101_extra_size {
char a[sizeof(B101)+1];
char b;
};
struct B101_extra_size var116;
#pragma pack(2)
typedef union {
char c;
int i __attribute__((aligned(32))) __attribute__((packed));
} B102;
B102 var117;
#pragma pack()
struct B102_extra_alignment {
char a;
B102 b;
};
struct B102_extra_alignment var118;
#pragma pack(1)
struct B102_extra_packed {
B102 a;
};
#pragma pack()
struct B102_extra_required_alignment {
char a;
struct B102_extra_packed b;
};
struct B102_extra_required_alignment var119;
struct B102_extra_size {
char a[sizeof(B102)+1];
char b;
};
struct B102_extra_size var120;
#pragma pack(2)
typedef union {
char c;
int i __attribute__((aligned(32))) __attribute__((packed));
} __attribute__((packed)) B103;
B103 var121;
#pragma pack()
struct B103_extra_alignment {
char a;
B103 b;
};
struct B103_extra_alignment var122;
#pragma pack(1)
struct B103_extra_packed {
B103 a;
};
#pragma pack()
struct B103_extra_required_alignment {
char a;
struct B103_extra_packed b;
};
struct B103_extra_required_alignment var123;
struct B103_extra_size {
char a[sizeof(B103)+1];
char b;
};
struct B103_extra_size var124;
typedef int B104 __attribute__((aligned(16)));
B104 var125;
struct B104_extra_alignment {
char a;
B104 b;
};
struct B104_extra_alignment var126;
#pragma pack(1)
struct B104_extra_packed {
B104 a;
};
#pragma pack()
struct B104_extra_required_alignment {
char a;
struct B104_extra_packed b;
};
struct B104_extra_required_alignment var127;
struct B104_extra_size {
char a[sizeof(B104)+1];
char b;
};
struct B104_extra_size var128;
#pragma pack(2)
typedef union {
char c;
A104 i __attribute__((aligned(32)));
} B105;
B105 var129;
#pragma pack()
struct B105_extra_alignment {
char a;
B105 b;
};
struct B105_extra_alignment var130;
#pragma pack(1)
struct B105_extra_packed {
B105 a;
};
#pragma pack()
struct B105_extra_required_alignment {
char a;
struct B105_extra_packed b;
};
struct B105_extra_required_alignment var131;
struct B105_extra_size {
char a[sizeof(B105)+1];
char b;
};
struct B105_extra_size var132;
#pragma pack(2)
typedef union {
char c;
A104 i __attribute__((aligned(32)));
} __attribute__((packed)) B106;
B106 var133;
#pragma pack()
struct B106_extra_alignment {
char a;
B106 b;
};
struct B106_extra_alignment var134;
#pragma pack(1)
struct B106_extra_packed {
B106 a;
};
#pragma pack()
struct B106_extra_required_alignment {
char a;
struct B106_extra_packed b;
};
struct B106_extra_required_alignment var135;
struct B106_extra_size {
char a[sizeof(B106)+1];
char b;
};
struct B106_extra_size var136;
#pragma pack(2)
typedef union {
char c;
A104 i __attribute__((aligned(32))) __attribute__((packed));
} B107;
B107 var137;
#pragma pack()
struct B107_extra_alignment {
char a;
B107 b;
};
struct B107_extra_alignment var138;
#pragma pack(1)
struct B107_extra_packed {
B107 a;
};
#pragma pack()
struct B107_extra_required_alignment {
char a;
struct B107_extra_packed b;
};
struct B107_extra_required_alignment var139;
struct B107_extra_size {
char a[sizeof(B107)+1];
char b;
};
struct B107_extra_size var140;
#pragma pack(2)
typedef union {
char c;
A104 i __attribute__((aligned(32))) __attribute__((packed));
} __attribute__((packed)) B108;
B108 var141;
#pragma pack()
struct B108_extra_alignment {
char a;
B108 b;
};
struct B108_extra_alignment var142;
#pragma pack(1)
struct B108_extra_packed {
B108 a;
};
#pragma pack()
struct B108_extra_required_alignment {
char a;
struct B108_extra_packed b;
};
struct B108_extra_required_alignment var143;
struct B108_extra_size {
char a[sizeof(B108)+1];
char b;
};
struct B108_extra_size var144;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A000) == 64, "");
_Static_assert(_Alignof(A000) == 32, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A000_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 66, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,i) == 256, "");
#endif
_Static_assert(sizeof(A001) == 64, "");
_Static_assert(_Alignof(A001) == 32, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A001_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 66, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,i) == 256, "");
#endif
_Static_assert(sizeof(A002) == 64, "");
_Static_assert(_Alignof(A002) == 32, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A002_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 66, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,i) == 256, "");
#endif
_Static_assert(sizeof(A003) == 64, "");
_Static_assert(_Alignof(A003) == 32, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A003_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 66, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,i) == 256, "");
#endif
_Static_assert(sizeof(A004) == 4, "");
_Static_assert(_Alignof(A004) == 16, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 6, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 64, "");
_Static_assert(_Alignof(A005) == 32, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A005_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 66, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,i) == 256, "");
#endif
_Static_assert(sizeof(A006) == 64, "");
_Static_assert(_Alignof(A006) == 32, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A006_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 66, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,i) == 256, "");
#endif
_Static_assert(sizeof(A007) == 64, "");
_Static_assert(_Alignof(A007) == 32, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A007_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 66, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,i) == 256, "");
#endif
_Static_assert(sizeof(A008) == 64, "");
_Static_assert(_Alignof(A008) == 32, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A008_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 66, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,i) == 256, "");
#endif
_Static_assert(sizeof(A100) == 6, "");
_Static_assert(_Alignof(A100) == 2, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A100_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 8, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,i) == 16, "");
#endif
_Static_assert(sizeof(A101) == 6, "");
_Static_assert(_Alignof(A101) == 2, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A101_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 8, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,i) == 16, "");
#endif
_Static_assert(sizeof(A102) == 6, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 8, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,i) == 16, "");
#endif
_Static_assert(sizeof(A103) == 6, "");
_Static_assert(_Alignof(A103) == 2, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A103_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 8, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,i) == 16, "");
#endif
_Static_assert(sizeof(A104) == 4, "");
_Static_assert(_Alignof(A104) == 16, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 6, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 6, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 8, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,i) == 16, "");
#endif
_Static_assert(sizeof(A106) == 6, "");
_Static_assert(_Alignof(A106) == 2, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A106_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 8, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,i) == 16, "");
#endif
_Static_assert(sizeof(A107) == 6, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 8, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,i) == 16, "");
#endif
_Static_assert(sizeof(A108) == 6, "");
_Static_assert(_Alignof(A108) == 2, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A108_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 8, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,i) == 16, "");
#endif
_Static_assert(sizeof(B000) == 32, "");
_Static_assert(_Alignof(B000) == 32, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B000_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 34, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,i) == 0, "");
#endif
_Static_assert(sizeof(B001) == 32, "");
_Static_assert(_Alignof(B001) == 32, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B001_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 34, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,i) == 0, "");
#endif
_Static_assert(sizeof(B002) == 32, "");
_Static_assert(_Alignof(B002) == 32, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B002_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 34, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,i) == 0, "");
#endif
_Static_assert(sizeof(B003) == 32, "");
_Static_assert(_Alignof(B003) == 32, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B003_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 34, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,i) == 0, "");
#endif
_Static_assert(sizeof(B004) == 4, "");
_Static_assert(_Alignof(B004) == 16, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B004_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 6, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 32, "");
_Static_assert(_Alignof(B005) == 32, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B005_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 34, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,i) == 0, "");
#endif
_Static_assert(sizeof(B006) == 32, "");
_Static_assert(_Alignof(B006) == 32, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B006_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 34, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,i) == 0, "");
#endif
_Static_assert(sizeof(B007) == 32, "");
_Static_assert(_Alignof(B007) == 32, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B007_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 34, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,i) == 0, "");
#endif
_Static_assert(sizeof(B008) == 32, "");
_Static_assert(_Alignof(B008) == 32, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B008_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 34, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,i) == 0, "");
#endif
_Static_assert(sizeof(B100) == 4, "");
_Static_assert(_Alignof(B100) == 2, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 6, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,i) == 0, "");
#endif
_Static_assert(sizeof(B101) == 4, "");
_Static_assert(_Alignof(B101) == 2, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 6, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,i) == 0, "");
#endif
_Static_assert(sizeof(B102) == 4, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 6, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,i) == 0, "");
#endif
_Static_assert(sizeof(B103) == 4, "");
_Static_assert(_Alignof(B103) == 2, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 6, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,i) == 0, "");
#endif
_Static_assert(sizeof(B104) == 4, "");
_Static_assert(_Alignof(B104) == 16, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B104_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 6, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 4, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 6, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,i) == 0, "");
#endif
_Static_assert(sizeof(B106) == 4, "");
_Static_assert(_Alignof(B106) == 2, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 6, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,i) == 0, "");
#endif
_Static_assert(sizeof(B107) == 4, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 6, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,i) == 0, "");
#endif
_Static_assert(sizeof(B108) == 4, "");
_Static_assert(_Alignof(B108) == 2, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 6, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,i) == 0, "");
#endif
// MAPPING|TWO|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A000) == 64, "");
_Static_assert(_Alignof(A000) == 32, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A000_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 66, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,i) == 256, "");
#endif
_Static_assert(sizeof(A001) == 64, "");
_Static_assert(_Alignof(A001) == 32, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A001_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 66, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,i) == 256, "");
#endif
_Static_assert(sizeof(A002) == 64, "");
_Static_assert(_Alignof(A002) == 32, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A002_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 66, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,i) == 256, "");
#endif
_Static_assert(sizeof(A003) == 64, "");
_Static_assert(_Alignof(A003) == 32, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A003_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 66, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,i) == 256, "");
#endif
_Static_assert(sizeof(A004) == 2, "");
_Static_assert(_Alignof(A004) == 16, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A004_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 4, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 64, "");
_Static_assert(_Alignof(A005) == 32, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A005_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 66, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,i) == 256, "");
#endif
_Static_assert(sizeof(A006) == 64, "");
_Static_assert(_Alignof(A006) == 32, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A006_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 66, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,i) == 256, "");
#endif
_Static_assert(sizeof(A007) == 64, "");
_Static_assert(_Alignof(A007) == 32, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A007_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 66, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,i) == 256, "");
#endif
_Static_assert(sizeof(A008) == 64, "");
_Static_assert(_Alignof(A008) == 32, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A008_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 66, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,i) == 256, "");
#endif
_Static_assert(sizeof(A100) == 4, "");
_Static_assert(_Alignof(A100) == 2, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 6, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,i) == 16, "");
#endif
_Static_assert(sizeof(A101) == 4, "");
_Static_assert(_Alignof(A101) == 2, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 6, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,i) == 16, "");
#endif
_Static_assert(sizeof(A102) == 4, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 6, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,i) == 16, "");
#endif
_Static_assert(sizeof(A103) == 4, "");
_Static_assert(_Alignof(A103) == 2, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 6, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,i) == 16, "");
#endif
_Static_assert(sizeof(A104) == 2, "");
_Static_assert(_Alignof(A104) == 16, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A104_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 4, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,i) == 16, "");
#endif
_Static_assert(sizeof(A106) == 4, "");
_Static_assert(_Alignof(A106) == 2, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 6, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,i) == 16, "");
#endif
_Static_assert(sizeof(A107) == 4, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 6, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,i) == 16, "");
#endif
_Static_assert(sizeof(A108) == 4, "");
_Static_assert(_Alignof(A108) == 2, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 6, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,i) == 16, "");
#endif
_Static_assert(sizeof(B000) == 32, "");
_Static_assert(_Alignof(B000) == 32, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B000_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 34, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,i) == 0, "");
#endif
_Static_assert(sizeof(B001) == 32, "");
_Static_assert(_Alignof(B001) == 32, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B001_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 34, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,i) == 0, "");
#endif
_Static_assert(sizeof(B002) == 32, "");
_Static_assert(_Alignof(B002) == 32, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B002_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 34, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,i) == 0, "");
#endif
_Static_assert(sizeof(B003) == 32, "");
_Static_assert(_Alignof(B003) == 32, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B003_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 34, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,i) == 0, "");
#endif
_Static_assert(sizeof(B004) == 2, "");
_Static_assert(_Alignof(B004) == 16, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B004_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 4, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 32, "");
_Static_assert(_Alignof(B005) == 32, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B005_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 34, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,i) == 0, "");
#endif
_Static_assert(sizeof(B006) == 32, "");
_Static_assert(_Alignof(B006) == 32, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B006_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 34, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,i) == 0, "");
#endif
_Static_assert(sizeof(B007) == 32, "");
_Static_assert(_Alignof(B007) == 32, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B007_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 34, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,i) == 0, "");
#endif
_Static_assert(sizeof(B008) == 32, "");
_Static_assert(_Alignof(B008) == 32, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B008_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 34, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,i) == 0, "");
#endif
_Static_assert(sizeof(B100) == 2, "");
_Static_assert(_Alignof(B100) == 2, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B100_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 4, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,i) == 0, "");
#endif
_Static_assert(sizeof(B101) == 2, "");
_Static_assert(_Alignof(B101) == 2, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B101_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 4, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,i) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,i) == 0, "");
#endif
_Static_assert(sizeof(B103) == 2, "");
_Static_assert(_Alignof(B103) == 2, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B103_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 4, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,i) == 0, "");
#endif
_Static_assert(sizeof(B104) == 2, "");
_Static_assert(_Alignof(B104) == 16, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B104_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 4, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,i) == 0, "");
#endif
_Static_assert(sizeof(B106) == 2, "");
_Static_assert(_Alignof(B106) == 2, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B106_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 4, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,i) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,i) == 0, "");
#endif
_Static_assert(sizeof(B108) == 2, "");
_Static_assert(_Alignof(B108) == 2, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B108_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 4, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,i) == 0, "");
#endif
// MAPPING|THREE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(A000) == 64, "");
_Static_assert(_Alignof(A000) == 32, "");
_Static_assert(sizeof(struct A000_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A000_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A000_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A000_extra_packed) == 1, "");
_Static_assert(sizeof(struct A000_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A000_extra_size) == 66, "");
_Static_assert(_Alignof(struct A000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A000,i) == 256, "");
#endif
_Static_assert(sizeof(A001) == 64, "");
_Static_assert(_Alignof(A001) == 32, "");
_Static_assert(sizeof(struct A001_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A001_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A001_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A001_extra_packed) == 1, "");
_Static_assert(sizeof(struct A001_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A001_extra_size) == 66, "");
_Static_assert(_Alignof(struct A001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A001,i) == 256, "");
#endif
_Static_assert(sizeof(A002) == 64, "");
_Static_assert(_Alignof(A002) == 32, "");
_Static_assert(sizeof(struct A002_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A002_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A002_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A002_extra_packed) == 1, "");
_Static_assert(sizeof(struct A002_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A002_extra_size) == 66, "");
_Static_assert(_Alignof(struct A002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A002,i) == 256, "");
#endif
_Static_assert(sizeof(A003) == 64, "");
_Static_assert(_Alignof(A003) == 32, "");
_Static_assert(sizeof(struct A003_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A003_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A003_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A003_extra_packed) == 1, "");
_Static_assert(sizeof(struct A003_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A003_extra_size) == 66, "");
_Static_assert(_Alignof(struct A003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A003,i) == 256, "");
#endif
_Static_assert(sizeof(A004) == 2, "");
_Static_assert(_Alignof(A004) == 16, "");
_Static_assert(sizeof(struct A004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A004_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A004_extra_packed) == 1, "");
_Static_assert(sizeof(struct A004_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A004_extra_size) == 4, "");
_Static_assert(_Alignof(struct A004_extra_size) == 1, "");
_Static_assert(sizeof(A005) == 64, "");
_Static_assert(_Alignof(A005) == 32, "");
_Static_assert(sizeof(struct A005_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A005_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A005_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A005_extra_packed) == 1, "");
_Static_assert(sizeof(struct A005_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A005_extra_size) == 66, "");
_Static_assert(_Alignof(struct A005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A005,i) == 256, "");
#endif
_Static_assert(sizeof(A006) == 64, "");
_Static_assert(_Alignof(A006) == 32, "");
_Static_assert(sizeof(struct A006_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A006_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A006_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A006_extra_packed) == 1, "");
_Static_assert(sizeof(struct A006_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A006_extra_size) == 66, "");
_Static_assert(_Alignof(struct A006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A006,i) == 256, "");
#endif
_Static_assert(sizeof(A007) == 64, "");
_Static_assert(_Alignof(A007) == 32, "");
_Static_assert(sizeof(struct A007_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A007_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A007_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A007_extra_packed) == 1, "");
_Static_assert(sizeof(struct A007_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A007_extra_size) == 66, "");
_Static_assert(_Alignof(struct A007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A007,i) == 256, "");
#endif
_Static_assert(sizeof(A008) == 64, "");
_Static_assert(_Alignof(A008) == 32, "");
_Static_assert(sizeof(struct A008_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A008_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A008_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A008_extra_packed) == 1, "");
_Static_assert(sizeof(struct A008_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A008_extra_size) == 66, "");
_Static_assert(_Alignof(struct A008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A008,i) == 256, "");
#endif
_Static_assert(sizeof(A100) == 4, "");
_Static_assert(_Alignof(A100) == 2, "");
_Static_assert(sizeof(struct A100_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A100_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A100_extra_packed) == 1, "");
_Static_assert(sizeof(struct A100_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A100_extra_size) == 6, "");
_Static_assert(_Alignof(struct A100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A100,i) == 16, "");
#endif
_Static_assert(sizeof(A101) == 4, "");
_Static_assert(_Alignof(A101) == 2, "");
_Static_assert(sizeof(struct A101_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A101_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A101_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A101_extra_packed) == 1, "");
_Static_assert(sizeof(struct A101_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A101_extra_size) == 6, "");
_Static_assert(_Alignof(struct A101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A101,i) == 16, "");
#endif
_Static_assert(sizeof(A102) == 4, "");
_Static_assert(_Alignof(A102) == 2, "");
_Static_assert(sizeof(struct A102_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A102_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A102_extra_packed) == 1, "");
_Static_assert(sizeof(struct A102_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A102_extra_size) == 6, "");
_Static_assert(_Alignof(struct A102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A102,i) == 16, "");
#endif
_Static_assert(sizeof(A103) == 4, "");
_Static_assert(_Alignof(A103) == 2, "");
_Static_assert(sizeof(struct A103_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A103_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A103_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A103_extra_packed) == 1, "");
_Static_assert(sizeof(struct A103_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A103_extra_size) == 6, "");
_Static_assert(_Alignof(struct A103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A103,i) == 16, "");
#endif
_Static_assert(sizeof(A104) == 2, "");
_Static_assert(_Alignof(A104) == 16, "");
_Static_assert(sizeof(struct A104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A104_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A104_extra_packed) == 1, "");
_Static_assert(sizeof(struct A104_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A104_extra_size) == 4, "");
_Static_assert(_Alignof(struct A104_extra_size) == 1, "");
_Static_assert(sizeof(A105) == 4, "");
_Static_assert(_Alignof(A105) == 2, "");
_Static_assert(sizeof(struct A105_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A105_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A105_extra_packed) == 1, "");
_Static_assert(sizeof(struct A105_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A105_extra_size) == 6, "");
_Static_assert(_Alignof(struct A105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A105,i) == 16, "");
#endif
_Static_assert(sizeof(A106) == 4, "");
_Static_assert(_Alignof(A106) == 2, "");
_Static_assert(sizeof(struct A106_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A106_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A106_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A106_extra_packed) == 1, "");
_Static_assert(sizeof(struct A106_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A106_extra_size) == 6, "");
_Static_assert(_Alignof(struct A106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A106,i) == 16, "");
#endif
_Static_assert(sizeof(A107) == 4, "");
_Static_assert(_Alignof(A107) == 2, "");
_Static_assert(sizeof(struct A107_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A107_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A107_extra_packed) == 1, "");
_Static_assert(sizeof(struct A107_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A107_extra_size) == 6, "");
_Static_assert(_Alignof(struct A107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A107,i) == 16, "");
#endif
_Static_assert(sizeof(A108) == 4, "");
_Static_assert(_Alignof(A108) == 2, "");
_Static_assert(sizeof(struct A108_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A108_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A108_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A108_extra_packed) == 1, "");
_Static_assert(sizeof(struct A108_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A108_extra_size) == 6, "");
_Static_assert(_Alignof(struct A108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A108,i) == 16, "");
#endif
_Static_assert(sizeof(B000) == 32, "");
_Static_assert(_Alignof(B000) == 32, "");
_Static_assert(sizeof(struct B000_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B000_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B000_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B000_extra_packed) == 1, "");
_Static_assert(sizeof(struct B000_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B000_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B000_extra_size) == 34, "");
_Static_assert(_Alignof(struct B000_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B000,i) == 0, "");
#endif
_Static_assert(sizeof(B001) == 32, "");
_Static_assert(_Alignof(B001) == 32, "");
_Static_assert(sizeof(struct B001_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B001_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B001_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B001_extra_packed) == 1, "");
_Static_assert(sizeof(struct B001_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B001_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B001_extra_size) == 34, "");
_Static_assert(_Alignof(struct B001_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B001,i) == 0, "");
#endif
_Static_assert(sizeof(B002) == 32, "");
_Static_assert(_Alignof(B002) == 32, "");
_Static_assert(sizeof(struct B002_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B002_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B002_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B002_extra_packed) == 1, "");
_Static_assert(sizeof(struct B002_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B002_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B002_extra_size) == 34, "");
_Static_assert(_Alignof(struct B002_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B002,i) == 0, "");
#endif
_Static_assert(sizeof(B003) == 32, "");
_Static_assert(_Alignof(B003) == 32, "");
_Static_assert(sizeof(struct B003_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B003_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B003_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B003_extra_packed) == 1, "");
_Static_assert(sizeof(struct B003_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B003_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B003_extra_size) == 34, "");
_Static_assert(_Alignof(struct B003_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B003,i) == 0, "");
#endif
_Static_assert(sizeof(B004) == 2, "");
_Static_assert(_Alignof(B004) == 16, "");
_Static_assert(sizeof(struct B004_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B004_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B004_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B004_extra_packed) == 1, "");
_Static_assert(sizeof(struct B004_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B004_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B004_extra_size) == 4, "");
_Static_assert(_Alignof(struct B004_extra_size) == 1, "");
_Static_assert(sizeof(B005) == 32, "");
_Static_assert(_Alignof(B005) == 32, "");
_Static_assert(sizeof(struct B005_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B005_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B005_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B005_extra_packed) == 1, "");
_Static_assert(sizeof(struct B005_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B005_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B005_extra_size) == 34, "");
_Static_assert(_Alignof(struct B005_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B005,i) == 0, "");
#endif
_Static_assert(sizeof(B006) == 32, "");
_Static_assert(_Alignof(B006) == 32, "");
_Static_assert(sizeof(struct B006_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B006_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B006_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B006_extra_packed) == 1, "");
_Static_assert(sizeof(struct B006_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B006_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B006_extra_size) == 34, "");
_Static_assert(_Alignof(struct B006_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B006,i) == 0, "");
#endif
_Static_assert(sizeof(B007) == 32, "");
_Static_assert(_Alignof(B007) == 32, "");
_Static_assert(sizeof(struct B007_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B007_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B007_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B007_extra_packed) == 1, "");
_Static_assert(sizeof(struct B007_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B007_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B007_extra_size) == 34, "");
_Static_assert(_Alignof(struct B007_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B007,i) == 0, "");
#endif
_Static_assert(sizeof(B008) == 32, "");
_Static_assert(_Alignof(B008) == 32, "");
_Static_assert(sizeof(struct B008_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct B008_extra_alignment) == 32, "");
_Static_assert(sizeof(struct B008_extra_packed) == 32, "");
_Static_assert(_Alignof(struct B008_extra_packed) == 1, "");
_Static_assert(sizeof(struct B008_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct B008_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B008_extra_size) == 34, "");
_Static_assert(_Alignof(struct B008_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B008,i) == 0, "");
#endif
_Static_assert(sizeof(B100) == 2, "");
_Static_assert(_Alignof(B100) == 2, "");
_Static_assert(sizeof(struct B100_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B100_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B100_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B100_extra_packed) == 1, "");
_Static_assert(sizeof(struct B100_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B100_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B100_extra_size) == 4, "");
_Static_assert(_Alignof(struct B100_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B100,i) == 0, "");
#endif
_Static_assert(sizeof(B101) == 2, "");
_Static_assert(_Alignof(B101) == 2, "");
_Static_assert(sizeof(struct B101_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B101_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B101_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B101_extra_packed) == 1, "");
_Static_assert(sizeof(struct B101_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B101_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B101_extra_size) == 4, "");
_Static_assert(_Alignof(struct B101_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B101,i) == 0, "");
#endif
_Static_assert(sizeof(B102) == 2, "");
_Static_assert(_Alignof(B102) == 2, "");
_Static_assert(sizeof(struct B102_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B102_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B102_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B102_extra_packed) == 1, "");
_Static_assert(sizeof(struct B102_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B102_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B102_extra_size) == 4, "");
_Static_assert(_Alignof(struct B102_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B102,i) == 0, "");
#endif
_Static_assert(sizeof(B103) == 2, "");
_Static_assert(_Alignof(B103) == 2, "");
_Static_assert(sizeof(struct B103_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B103_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B103_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B103_extra_packed) == 1, "");
_Static_assert(sizeof(struct B103_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B103_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B103_extra_size) == 4, "");
_Static_assert(_Alignof(struct B103_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B103,i) == 0, "");
#endif
_Static_assert(sizeof(B104) == 2, "");
_Static_assert(_Alignof(B104) == 16, "");
_Static_assert(sizeof(struct B104_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct B104_extra_alignment) == 16, "");
_Static_assert(sizeof(struct B104_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B104_extra_packed) == 1, "");
_Static_assert(sizeof(struct B104_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B104_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B104_extra_size) == 4, "");
_Static_assert(_Alignof(struct B104_extra_size) == 1, "");
_Static_assert(sizeof(B105) == 2, "");
_Static_assert(_Alignof(B105) == 2, "");
_Static_assert(sizeof(struct B105_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B105_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B105_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B105_extra_packed) == 1, "");
_Static_assert(sizeof(struct B105_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B105_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B105_extra_size) == 4, "");
_Static_assert(_Alignof(struct B105_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B105,i) == 0, "");
#endif
_Static_assert(sizeof(B106) == 2, "");
_Static_assert(_Alignof(B106) == 2, "");
_Static_assert(sizeof(struct B106_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B106_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B106_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B106_extra_packed) == 1, "");
_Static_assert(sizeof(struct B106_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B106_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B106_extra_size) == 4, "");
_Static_assert(_Alignof(struct B106_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B106,i) == 0, "");
#endif
_Static_assert(sizeof(B107) == 2, "");
_Static_assert(_Alignof(B107) == 2, "");
_Static_assert(sizeof(struct B107_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B107_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B107_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B107_extra_packed) == 1, "");
_Static_assert(sizeof(struct B107_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B107_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B107_extra_size) == 4, "");
_Static_assert(_Alignof(struct B107_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B107,i) == 0, "");
#endif
_Static_assert(sizeof(B108) == 2, "");
_Static_assert(_Alignof(B108) == 2, "");
_Static_assert(sizeof(struct B108_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B108_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B108_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B108_extra_packed) == 1, "");
_Static_assert(sizeof(struct B108_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B108_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B108_extra_size) == 4, "");
_Static_assert(_Alignof(struct B108_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B108,i) == 0, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0049_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char c:1;
int:0 __attribute__((packed));
char d;
} X;
X var1;
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var2;
#pragma pack(1)
struct X_extra_packed {
X a;
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var3;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var4;
typedef struct {
char c:1;
int:0;
char d;
} Y;
Y var5;
struct Y_extra_alignment {
char a;
Y b;
};
struct Y_extra_alignment var6;
#pragma pack(1)
struct Y_extra_packed {
Y a;
};
#pragma pack()
struct Y_extra_required_alignment {
char a;
struct Y_extra_packed b;
};
struct Y_extra_required_alignment var7;
struct Y_extra_size {
char a[sizeof(Y)+1];
char b;
};
struct Y_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(X) == 5, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 5, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 7, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,d) == 32, "");
#endif
_Static_assert(sizeof(Y) == 5, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 5, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 7, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 32, "");
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(X) == 8, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 8, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 10, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,d) == 32, "");
#endif
_Static_assert(sizeof(Y) == 8, "");
_Static_assert(_Alignof(Y) == 4, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Y_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 32, "");
#endif
// MAPPING|THREE|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(THREE)
_Static_assert(sizeof(X) == 2, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 2, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 4, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,d) == 8, "");
#endif
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 8, "");
#endif
// MAPPING|FOUR|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(FOUR)
_Static_assert(sizeof(X) == 4, "");
_Static_assert(_Alignof(X) == 4, "");
_Static_assert(sizeof(struct X_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 4, "");
_Static_assert(sizeof(struct X_extra_packed) == 4, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 6, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,d) == 8, "");
#endif
_Static_assert(sizeof(Y) == 8, "");
_Static_assert(_Alignof(Y) == 4, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Y_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 32, "");
#endif
// MAPPING|FIVE|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FIVE)
_Static_assert(sizeof(X) == 3, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 3, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 5, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,d) == 16, "");
#endif
_Static_assert(sizeof(Y) == 3, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 3, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 5, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 16, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0028_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(4)) typedef char Char;
#else
typedef char Char __attribute__((aligned(4)));
#endif
Char var1;
struct Char_extra_alignment {
char a;
Char b;
};
struct Char_extra_alignment var2;
#pragma pack(1)
struct Char_extra_packed {
#ifdef MSVC
char a[sizeof(Char)];
#else
Char a;
#endif
};
#pragma pack()
struct Char_extra_required_alignment {
char a;
struct Char_extra_packed b;
};
struct Char_extra_required_alignment var3;
struct Char_extra_size {
char a[sizeof(Char)+1];
char b;
};
struct Char_extra_size var4;
#pragma pack(1)
typedef struct {
char c;
Char a;
} A;
A var5;
#pragma pack()
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var6;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var7;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var8;
typedef struct {
char c;
#ifdef MSVC
__declspec(align(4)) char a;
#else
char a __attribute__((aligned(4)));
#endif
} B;
B var9;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var10;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var11;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var12;
typedef struct {
char c;
#ifdef MSVC
__declspec(align(8)) Char a;
#else
Char a __attribute__((aligned(8)));
#endif
} C;
C var13;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var14;
#pragma pack(1)
struct C_extra_packed {
#ifdef MSVC
char a[sizeof(C)];
#else
C a;
#endif
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var15;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var16;
typedef struct {
char c;
#ifdef MSVC
__declspec(align(2)) Char a;
#else
Char a __attribute__((aligned(2)));
#endif
} D;
D var17;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var18;
#pragma pack(1)
struct D_extra_packed {
#ifdef MSVC
char a[sizeof(D)];
#else
D a;
#endif
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var19;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var20;
#pragma pack(1)
typedef struct {
char c;
#ifdef MSVC
__declspec(align(8)) Char a;
#else
Char a __attribute__((aligned(8)));
#endif
} E;
E var21;
#pragma pack()
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var22;
#pragma pack(1)
struct E_extra_packed {
#ifdef MSVC
char a[sizeof(E)];
#else
E a;
#endif
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var23;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var24;
#pragma pack(1)
typedef struct {
char c;
Char a:1;
} F;
F var25;
#pragma pack()
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var26;
#pragma pack(1)
struct F_extra_packed {
#ifdef MSVC
char a[sizeof(F)];
#else
F a;
#endif
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var27;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var28;
#pragma pack(1)
typedef struct {
char c;
#ifdef MSVC
__declspec(align(8)) Char a:1;
#else
Char a:1 __attribute__((aligned(8)));
#endif
} G;
G var29;
#pragma pack()
struct G_extra_alignment {
char a;
G b;
};
struct G_extra_alignment var30;
#pragma pack(1)
struct G_extra_packed {
#ifdef MSVC
char a[sizeof(G)];
#else
G a;
#endif
};
#pragma pack()
struct G_extra_required_alignment {
char a;
struct G_extra_packed b;
};
struct G_extra_required_alignment var31;
struct G_extra_size {
char a[sizeof(G)+1];
char b;
};
struct G_extra_size var32;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|avr-avr2-other-eabi:Gcc|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-windows-gnu:Gcc|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|msp430-msp430-other-eabi:Clang|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") AvrUnknownUnknown|Some("avr-avr2-other-eabi") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686PcWindowsGnu|Some("x86-i686-windows-gnu") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Msp430NoneElf|Some("msp430-msp430-other-eabi") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(Char) == 1, "");
_Static_assert(_Alignof(Char) == 4, "");
_Static_assert(sizeof(struct Char_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Char_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Char_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Char_extra_packed) == 1, "");
_Static_assert(sizeof(struct Char_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Char_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Char_extra_size) == 3, "");
_Static_assert(_Alignof(struct Char_extra_size) == 1, "");
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 8, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,a) == 32, "");
#endif
_Static_assert(sizeof(C) == 16, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 16, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 18, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,a) == 64, "");
#endif
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,a) == 32, "");
#endif
_Static_assert(sizeof(E) == 2, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 2, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 4, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,a) == 8, "");
#endif
_Static_assert(sizeof(F) == 2, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 2, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 4, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,a) == 8, "");
#endif
_Static_assert(sizeof(G) == 2, "");
_Static_assert(_Alignof(G) == 1, "");
_Static_assert(sizeof(struct G_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_packed) == 2, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 4, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,a) == 8, "");
#endif
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(Char) == 1, "");
_Static_assert(_Alignof(Char) == 4, "");
_Static_assert(sizeof(struct Char_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Char_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Char_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Char_extra_packed) == 1, "");
_Static_assert(sizeof(struct Char_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Char_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Char_extra_size) == 3, "");
_Static_assert(_Alignof(struct Char_extra_size) == 1, "");
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,a) == 32, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,a) == 32, "");
#endif
_Static_assert(sizeof(C) == 16, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 16, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 18, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,a) == 64, "");
#endif
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,a) == 32, "");
#endif
_Static_assert(sizeof(E) == 16, "");
_Static_assert(_Alignof(E) == 8, "");
_Static_assert(sizeof(struct E_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 8, "");
_Static_assert(sizeof(struct E_extra_packed) == 16, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 18, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,a) == 64, "");
#endif
_Static_assert(sizeof(F) == 5, "");
_Static_assert(_Alignof(F) == 4, "");
_Static_assert(sizeof(struct F_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 4, "");
_Static_assert(sizeof(struct F_extra_packed) == 5, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 7, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,a) == 32, "");
#endif
_Static_assert(sizeof(G) == 9, "");
_Static_assert(_Alignof(G) == 8, "");
_Static_assert(sizeof(struct G_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 8, "");
_Static_assert(sizeof(struct G_extra_packed) == 9, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 11, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,a) == 64, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0082_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
long long a:1;
long long:0;
long long b:1;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
A a;
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef union {
long long a:1;
long long:0;
long long b:1;
} A_;
A_ var5;
struct A__extra_alignment {
char a;
A_ b;
};
struct A__extra_alignment var6;
#pragma pack(1)
struct A__extra_packed {
A_ a;
};
#pragma pack()
struct A__extra_required_alignment {
char a;
struct A__extra_packed b;
};
struct A__extra_required_alignment var7;
struct A__extra_size {
char a[sizeof(A_)+1];
char b;
};
struct A__extra_size var8;
typedef struct {
long long a:1;
long long:0 __attribute__((packed));
long long b:1;
} B;
B var9;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var10;
#pragma pack(1)
struct B_extra_packed {
B a;
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var11;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var12;
typedef union {
long long a:1;
long long:0 __attribute__((packed));
long long b:1;
} B_;
B_ var13;
struct B__extra_alignment {
char a;
B_ b;
};
struct B__extra_alignment var14;
#pragma pack(1)
struct B__extra_packed {
B_ a;
};
#pragma pack()
struct B__extra_required_alignment {
char a;
struct B__extra_packed b;
};
struct B__extra_required_alignment var15;
struct B__extra_size {
char a[sizeof(B_)+1];
char b;
};
struct B__extra_size var16;
typedef struct {
long long a:1;
long long:0;
long long b:1;
} __attribute__((packed)) C;
C var17;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var18;
#pragma pack(1)
struct C_extra_packed {
C a;
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var19;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var20;
typedef union {
long long a:1;
long long:0;
long long b:1;
} __attribute__((packed)) C_;
C_ var21;
struct C__extra_alignment {
char a;
C_ b;
};
struct C__extra_alignment var22;
#pragma pack(1)
struct C__extra_packed {
C_ a;
};
#pragma pack()
struct C__extra_required_alignment {
char a;
struct C__extra_packed b;
};
struct C__extra_required_alignment var23;
struct C__extra_size {
char a[sizeof(C_)+1];
char b;
};
struct C__extra_size var24;
#pragma pack(1)
typedef struct {
long long a:1;
long long:0;
long long b:1;
} __attribute__((packed)) D;
D var25;
#pragma pack()
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var26;
#pragma pack(1)
struct D_extra_packed {
D a;
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var27;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var28;
#pragma pack(1)
typedef union {
long long a:1;
long long:0;
long long b:1;
} __attribute__((packed)) D_;
D_ var29;
#pragma pack()
struct D__extra_alignment {
char a;
D_ b;
};
struct D__extra_alignment var30;
#pragma pack(1)
struct D__extra_packed {
D_ a;
};
#pragma pack()
struct D__extra_required_alignment {
char a;
struct D__extra_packed b;
};
struct D__extra_required_alignment var31;
struct D__extra_size {
char a[sizeof(D_)+1];
char b;
};
struct D__extra_size var32;
#pragma pack(1)
typedef struct {
long long a:1;
long long:0 __attribute__((aligned(128)));
long long b:1;
} __attribute__((packed)) E;
E var33;
#pragma pack()
struct E_extra_alignment {
char a;
E b;
};
struct E_extra_alignment var34;
#pragma pack(1)
struct E_extra_packed {
E a;
};
#pragma pack()
struct E_extra_required_alignment {
char a;
struct E_extra_packed b;
};
struct E_extra_required_alignment var35;
struct E_extra_size {
char a[sizeof(E)+1];
char b;
};
struct E_extra_size var36;
#pragma pack(1)
typedef union {
long long a:1;
long long:0 __attribute__((aligned(128)));
long long b:1;
} __attribute__((packed)) E_;
E_ var37;
#pragma pack()
struct E__extra_alignment {
char a;
E_ b;
};
struct E__extra_alignment var38;
#pragma pack(1)
struct E__extra_packed {
E_ a;
};
#pragma pack()
struct E__extra_required_alignment {
char a;
struct E__extra_packed b;
};
struct E__extra_required_alignment var39;
struct E__extra_size {
char a[sizeof(E_)+1];
char b;
};
struct E__extra_size var40;
typedef struct {
long long a:1;
long long:0 __attribute__((aligned(128)));
long long b:1;
} __attribute__((packed)) F;
F var41;
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var42;
#pragma pack(1)
struct F_extra_packed {
F a;
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var43;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var44;
typedef union {
long long a:1;
long long:0 __attribute__((aligned(128)));
long long b:1;
} __attribute__((packed)) F_;
F_ var45;
struct F__extra_alignment {
char a;
F_ b;
};
struct F__extra_alignment var46;
#pragma pack(1)
struct F__extra_packed {
F_ a;
};
#pragma pack()
struct F__extra_required_alignment {
char a;
struct F__extra_packed b;
};
struct F__extra_required_alignment var47;
struct F__extra_size {
char a[sizeof(F_)+1];
char b;
};
struct F__extra_size var48;
typedef struct {
long long a:1;
long long:0 __attribute__((aligned(128))) __attribute__((packed));
long long b:1;
} G;
G var49;
struct G_extra_alignment {
char a;
G b;
};
struct G_extra_alignment var50;
#pragma pack(1)
struct G_extra_packed {
G a;
};
#pragma pack()
struct G_extra_required_alignment {
char a;
struct G_extra_packed b;
};
struct G_extra_required_alignment var51;
struct G_extra_size {
char a[sizeof(G)+1];
char b;
};
struct G_extra_size var52;
typedef union {
long long a:1;
long long:0 __attribute__((aligned(128))) __attribute__((packed));
long long b:1;
} G_;
G_ var53;
struct G__extra_alignment {
char a;
G_ b;
};
struct G__extra_alignment var54;
#pragma pack(1)
struct G__extra_packed {
G_ a;
};
#pragma pack()
struct G__extra_required_alignment {
char a;
struct G__extra_packed b;
};
struct G__extra_required_alignment var55;
struct G__extra_size {
char a[sizeof(G_)+1];
char b;
};
struct G__extra_size var56;
#pragma pack(1)
typedef struct {
long long a:1;
long long:0 __attribute__((aligned(128))) __attribute__((packed));
long long b:1;
} H;
H var57;
#pragma pack()
struct H_extra_alignment {
char a;
H b;
};
struct H_extra_alignment var58;
#pragma pack(1)
struct H_extra_packed {
H a;
};
#pragma pack()
struct H_extra_required_alignment {
char a;
struct H_extra_packed b;
};
struct H_extra_required_alignment var59;
struct H_extra_size {
char a[sizeof(H)+1];
char b;
};
struct H_extra_size var60;
#pragma pack(1)
typedef union {
long long a:1;
long long:0 __attribute__((aligned(128))) __attribute__((packed));
long long b:1;
} H_;
H_ var61;
#pragma pack()
struct H__extra_alignment {
char a;
H_ b;
};
struct H__extra_alignment var62;
#pragma pack(1)
struct H__extra_packed {
H_ a;
};
#pragma pack()
struct H__extra_required_alignment {
char a;
struct H__extra_packed b;
};
struct H__extra_required_alignment var63;
struct H__extra_size {
char a[sizeof(H_)+1];
char b;
};
struct H__extra_size var64;
typedef long long I __attribute__((aligned(128)));
I var65;
struct I_extra_alignment {
char a;
I b;
};
struct I_extra_alignment var66;
#pragma pack(1)
struct I_extra_packed {
I a;
};
#pragma pack()
struct I_extra_required_alignment {
char a;
struct I_extra_packed b;
};
struct I_extra_required_alignment var67;
struct I_extra_size {
char a[sizeof(I)+1];
char b;
};
struct I_extra_size var68;
typedef struct {
long long a:1;
I:0 __attribute__((packed));
long long b:1;
} J;
J var69;
struct J_extra_alignment {
char a;
J b;
};
struct J_extra_alignment var70;
#pragma pack(1)
struct J_extra_packed {
J a;
};
#pragma pack()
struct J_extra_required_alignment {
char a;
struct J_extra_packed b;
};
struct J_extra_required_alignment var71;
struct J_extra_size {
char a[sizeof(J)+1];
char b;
};
struct J_extra_size var72;
typedef union {
long long a:1;
I:0 __attribute__((packed));
long long b:1;
} J_;
J_ var73;
struct J__extra_alignment {
char a;
J_ b;
};
struct J__extra_alignment var74;
#pragma pack(1)
struct J__extra_packed {
J_ a;
};
#pragma pack()
struct J__extra_required_alignment {
char a;
struct J__extra_packed b;
};
struct J__extra_required_alignment var75;
struct J__extra_size {
char a[sizeof(J_)+1];
char b;
};
struct J__extra_size var76;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|hexagon-generic-linux-musl:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mipsel-mips32-other-none:Clang|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv32-baseline_rv32-linux-gnu:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc-v8-linux-gnu:Gcc|sparc64-v9-solaris-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") MipselSonyPsp|None MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None MipselUnknownNone|Some("mipsel-mips32-other-none") Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 16, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 18, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,b) == 64, "");
#endif
_Static_assert(sizeof(A_) == 8, "");
_Static_assert(_Alignof(A_) == 8, "");
_Static_assert(sizeof(struct A__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 8, "");
_Static_assert(sizeof(struct A__extra_packed) == 8, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 10, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,b) == 0, "");
#endif
_Static_assert(sizeof(B) == 16, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 18, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,b) == 64, "");
#endif
_Static_assert(sizeof(B_) == 8, "");
_Static_assert(_Alignof(B_) == 8, "");
_Static_assert(sizeof(struct B__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 8, "");
_Static_assert(sizeof(struct B__extra_packed) == 8, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 10, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,b) == 0, "");
#endif
_Static_assert(sizeof(C) == 9, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 9, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 11, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 64, "");
#endif
_Static_assert(sizeof(C_) == 1, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 1, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 3, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,b) == 0, "");
#endif
_Static_assert(sizeof(D) == 9, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 9, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 11, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,b) == 64, "");
#endif
_Static_assert(sizeof(D_) == 1, "");
_Static_assert(_Alignof(D_) == 1, "");
_Static_assert(sizeof(struct D__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D__extra_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_packed) == 1, "");
_Static_assert(_Alignof(struct D__extra_packed) == 1, "");
_Static_assert(sizeof(struct D__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_size) == 3, "");
_Static_assert(_Alignof(struct D__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D_,b) == 0, "");
#endif
_Static_assert(sizeof(E) == 129, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 129, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 131, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,b) == 1024, "");
#endif
_Static_assert(sizeof(E_) == 1, "");
_Static_assert(_Alignof(E_) == 1, "");
_Static_assert(sizeof(struct E__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E__extra_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_packed) == 1, "");
_Static_assert(_Alignof(struct E__extra_packed) == 1, "");
_Static_assert(sizeof(struct E__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_size) == 3, "");
_Static_assert(_Alignof(struct E__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E_,b) == 0, "");
#endif
_Static_assert(sizeof(F) == 129, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 129, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 131, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,b) == 1024, "");
#endif
_Static_assert(sizeof(F_) == 1, "");
_Static_assert(_Alignof(F_) == 1, "");
_Static_assert(sizeof(struct F__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F__extra_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_packed) == 1, "");
_Static_assert(_Alignof(struct F__extra_packed) == 1, "");
_Static_assert(sizeof(struct F__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_size) == 3, "");
_Static_assert(_Alignof(struct F__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F_,b) == 0, "");
#endif
_Static_assert(sizeof(G) == 136, "");
_Static_assert(_Alignof(G) == 8, "");
_Static_assert(sizeof(struct G_extra_alignment) == 144, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 8, "");
_Static_assert(sizeof(struct G_extra_packed) == 136, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 137, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 138, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,b) == 1024, "");
#endif
_Static_assert(sizeof(G_) == 8, "");
_Static_assert(_Alignof(G_) == 8, "");
_Static_assert(sizeof(struct G__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct G__extra_alignment) == 8, "");
_Static_assert(sizeof(struct G__extra_packed) == 8, "");
_Static_assert(_Alignof(struct G__extra_packed) == 1, "");
_Static_assert(sizeof(struct G__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G__extra_size) == 10, "");
_Static_assert(_Alignof(struct G__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G_,b) == 0, "");
#endif
_Static_assert(sizeof(H) == 129, "");
_Static_assert(_Alignof(H) == 1, "");
_Static_assert(sizeof(struct H_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_packed) == 129, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 131, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,b) == 1024, "");
#endif
_Static_assert(sizeof(H_) == 1, "");
_Static_assert(_Alignof(H_) == 1, "");
_Static_assert(sizeof(struct H__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct H__extra_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_packed) == 1, "");
_Static_assert(_Alignof(struct H__extra_packed) == 1, "");
_Static_assert(sizeof(struct H__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct H__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_size) == 3, "");
_Static_assert(_Alignof(struct H__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H_,b) == 0, "");
#endif
_Static_assert(sizeof(I) == 8, "");
_Static_assert(_Alignof(I) == 128, "");
_Static_assert(sizeof(struct I_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 128, "");
_Static_assert(sizeof(struct I_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 10, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 136, "");
_Static_assert(_Alignof(J) == 8, "");
_Static_assert(sizeof(struct J_extra_alignment) == 144, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 8, "");
_Static_assert(sizeof(struct J_extra_packed) == 136, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 137, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 138, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,b) == 1024, "");
#endif
_Static_assert(sizeof(J_) == 8, "");
_Static_assert(_Alignof(J_) == 8, "");
_Static_assert(sizeof(struct J__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct J__extra_alignment) == 8, "");
_Static_assert(sizeof(struct J__extra_packed) == 8, "");
_Static_assert(_Alignof(struct J__extra_packed) == 1, "");
_Static_assert(sizeof(struct J__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J__extra_size) == 10, "");
_Static_assert(_Alignof(struct J__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J_,b) == 0, "");
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(TWO)
_Static_assert(sizeof(A) == 16, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 18, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,b) == 64, "");
#endif
_Static_assert(sizeof(A_) == 8, "");
_Static_assert(_Alignof(A_) == 8, "");
_Static_assert(sizeof(struct A__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 8, "");
_Static_assert(sizeof(struct A__extra_packed) == 8, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 10, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,b) == 0, "");
#endif
_Static_assert(sizeof(B) == 16, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 18, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,b) == 64, "");
#endif
_Static_assert(sizeof(B_) == 8, "");
_Static_assert(_Alignof(B_) == 8, "");
_Static_assert(sizeof(struct B__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 8, "");
_Static_assert(sizeof(struct B__extra_packed) == 8, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 10, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,b) == 0, "");
#endif
_Static_assert(sizeof(C) == 16, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 16, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 18, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 64, "");
#endif
_Static_assert(sizeof(C_) == 8, "");
_Static_assert(_Alignof(C_) == 8, "");
_Static_assert(sizeof(struct C__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 8, "");
_Static_assert(sizeof(struct C__extra_packed) == 8, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 10, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,b) == 0, "");
#endif
_Static_assert(sizeof(D) == 16, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 18, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,b) == 64, "");
#endif
_Static_assert(sizeof(D_) == 8, "");
_Static_assert(_Alignof(D_) == 8, "");
_Static_assert(sizeof(struct D__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D__extra_alignment) == 8, "");
_Static_assert(sizeof(struct D__extra_packed) == 8, "");
_Static_assert(_Alignof(struct D__extra_packed) == 1, "");
_Static_assert(sizeof(struct D__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_size) == 10, "");
_Static_assert(_Alignof(struct D__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D_,b) == 0, "");
#endif
_Static_assert(sizeof(E) == 256, "");
_Static_assert(_Alignof(E) == 128, "");
_Static_assert(sizeof(struct E_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 128, "");
_Static_assert(sizeof(struct E_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 258, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,b) == 1024, "");
#endif
_Static_assert(sizeof(E_) == 128, "");
_Static_assert(_Alignof(E_) == 128, "");
_Static_assert(sizeof(struct E__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct E__extra_alignment) == 128, "");
_Static_assert(sizeof(struct E__extra_packed) == 128, "");
_Static_assert(_Alignof(struct E__extra_packed) == 1, "");
_Static_assert(sizeof(struct E__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct E__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_size) == 130, "");
_Static_assert(_Alignof(struct E__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E_,b) == 0, "");
#endif
_Static_assert(sizeof(F) == 256, "");
_Static_assert(_Alignof(F) == 128, "");
_Static_assert(sizeof(struct F_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 128, "");
_Static_assert(sizeof(struct F_extra_packed) == 256, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 258, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,b) == 1024, "");
#endif
_Static_assert(sizeof(F_) == 128, "");
_Static_assert(_Alignof(F_) == 128, "");
_Static_assert(sizeof(struct F__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct F__extra_alignment) == 128, "");
_Static_assert(sizeof(struct F__extra_packed) == 128, "");
_Static_assert(_Alignof(struct F__extra_packed) == 1, "");
_Static_assert(sizeof(struct F__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct F__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_size) == 130, "");
_Static_assert(_Alignof(struct F__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F_,b) == 0, "");
#endif
_Static_assert(sizeof(G) == 256, "");
_Static_assert(_Alignof(G) == 128, "");
_Static_assert(sizeof(struct G_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 128, "");
_Static_assert(sizeof(struct G_extra_packed) == 256, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 258, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,b) == 1024, "");
#endif
_Static_assert(sizeof(G_) == 128, "");
_Static_assert(_Alignof(G_) == 128, "");
_Static_assert(sizeof(struct G__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct G__extra_alignment) == 128, "");
_Static_assert(sizeof(struct G__extra_packed) == 128, "");
_Static_assert(_Alignof(struct G__extra_packed) == 1, "");
_Static_assert(sizeof(struct G__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct G__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G__extra_size) == 130, "");
_Static_assert(_Alignof(struct G__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G_,b) == 0, "");
#endif
_Static_assert(sizeof(H) == 256, "");
_Static_assert(_Alignof(H) == 128, "");
_Static_assert(sizeof(struct H_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 128, "");
_Static_assert(sizeof(struct H_extra_packed) == 256, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 258, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,b) == 1024, "");
#endif
_Static_assert(sizeof(H_) == 128, "");
_Static_assert(_Alignof(H_) == 128, "");
_Static_assert(sizeof(struct H__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct H__extra_alignment) == 128, "");
_Static_assert(sizeof(struct H__extra_packed) == 128, "");
_Static_assert(_Alignof(struct H__extra_packed) == 1, "");
_Static_assert(sizeof(struct H__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct H__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_size) == 130, "");
_Static_assert(_Alignof(struct H__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H_,b) == 0, "");
#endif
_Static_assert(sizeof(I) == 8, "");
_Static_assert(_Alignof(I) == 128, "");
_Static_assert(sizeof(struct I_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 128, "");
_Static_assert(sizeof(struct I_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 10, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 256, "");
_Static_assert(_Alignof(J) == 128, "");
_Static_assert(sizeof(struct J_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 128, "");
_Static_assert(sizeof(struct J_extra_packed) == 256, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 258, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,b) == 1024, "");
#endif
_Static_assert(sizeof(J_) == 128, "");
_Static_assert(_Alignof(J_) == 128, "");
_Static_assert(sizeof(struct J__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct J__extra_alignment) == 128, "");
_Static_assert(sizeof(struct J__extra_packed) == 128, "");
_Static_assert(_Alignof(struct J__extra_packed) == 1, "");
_Static_assert(sizeof(struct J__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct J__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J__extra_size) == 130, "");
_Static_assert(_Alignof(struct J__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J_,b) == 0, "");
#endif
// MAPPING|THREE|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(THREE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,b) == 32, "");
#endif
_Static_assert(sizeof(A_) == 4, "");
_Static_assert(_Alignof(A_) == 4, "");
_Static_assert(sizeof(struct A__extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 4, "");
_Static_assert(sizeof(struct A__extra_packed) == 4, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 6, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,b) == 0, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,b) == 32, "");
#endif
_Static_assert(sizeof(B_) == 4, "");
_Static_assert(_Alignof(B_) == 4, "");
_Static_assert(sizeof(struct B__extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 4, "");
_Static_assert(sizeof(struct B__extra_packed) == 4, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 6, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,b) == 0, "");
#endif
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 32, "");
#endif
_Static_assert(sizeof(C_) == 4, "");
_Static_assert(_Alignof(C_) == 4, "");
_Static_assert(sizeof(struct C__extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 4, "");
_Static_assert(sizeof(struct C__extra_packed) == 4, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 6, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,b) == 0, "");
#endif
_Static_assert(sizeof(D) == 8, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 10, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,b) == 32, "");
#endif
_Static_assert(sizeof(D_) == 4, "");
_Static_assert(_Alignof(D_) == 4, "");
_Static_assert(sizeof(struct D__extra_alignment) == 8, "");
_Static_assert(_Alignof(struct D__extra_alignment) == 4, "");
_Static_assert(sizeof(struct D__extra_packed) == 4, "");
_Static_assert(_Alignof(struct D__extra_packed) == 1, "");
_Static_assert(sizeof(struct D__extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct D__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_size) == 6, "");
_Static_assert(_Alignof(struct D__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D_,b) == 0, "");
#endif
_Static_assert(sizeof(E) == 256, "");
_Static_assert(_Alignof(E) == 128, "");
_Static_assert(sizeof(struct E_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 128, "");
_Static_assert(sizeof(struct E_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 258, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,b) == 1024, "");
#endif
_Static_assert(sizeof(E_) == 128, "");
_Static_assert(_Alignof(E_) == 128, "");
_Static_assert(sizeof(struct E__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct E__extra_alignment) == 128, "");
_Static_assert(sizeof(struct E__extra_packed) == 128, "");
_Static_assert(_Alignof(struct E__extra_packed) == 1, "");
_Static_assert(sizeof(struct E__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct E__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_size) == 130, "");
_Static_assert(_Alignof(struct E__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E_,b) == 0, "");
#endif
_Static_assert(sizeof(F) == 256, "");
_Static_assert(_Alignof(F) == 128, "");
_Static_assert(sizeof(struct F_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 128, "");
_Static_assert(sizeof(struct F_extra_packed) == 256, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 258, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,b) == 1024, "");
#endif
_Static_assert(sizeof(F_) == 128, "");
_Static_assert(_Alignof(F_) == 128, "");
_Static_assert(sizeof(struct F__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct F__extra_alignment) == 128, "");
_Static_assert(sizeof(struct F__extra_packed) == 128, "");
_Static_assert(_Alignof(struct F__extra_packed) == 1, "");
_Static_assert(sizeof(struct F__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct F__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_size) == 130, "");
_Static_assert(_Alignof(struct F__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F_,b) == 0, "");
#endif
_Static_assert(sizeof(G) == 256, "");
_Static_assert(_Alignof(G) == 128, "");
_Static_assert(sizeof(struct G_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 128, "");
_Static_assert(sizeof(struct G_extra_packed) == 256, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 258, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,b) == 1024, "");
#endif
_Static_assert(sizeof(G_) == 128, "");
_Static_assert(_Alignof(G_) == 128, "");
_Static_assert(sizeof(struct G__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct G__extra_alignment) == 128, "");
_Static_assert(sizeof(struct G__extra_packed) == 128, "");
_Static_assert(_Alignof(struct G__extra_packed) == 1, "");
_Static_assert(sizeof(struct G__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct G__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G__extra_size) == 130, "");
_Static_assert(_Alignof(struct G__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G_,b) == 0, "");
#endif
_Static_assert(sizeof(H) == 256, "");
_Static_assert(_Alignof(H) == 128, "");
_Static_assert(sizeof(struct H_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 128, "");
_Static_assert(sizeof(struct H_extra_packed) == 256, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 258, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,b) == 1024, "");
#endif
_Static_assert(sizeof(H_) == 128, "");
_Static_assert(_Alignof(H_) == 128, "");
_Static_assert(sizeof(struct H__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct H__extra_alignment) == 128, "");
_Static_assert(sizeof(struct H__extra_packed) == 128, "");
_Static_assert(_Alignof(struct H__extra_packed) == 1, "");
_Static_assert(sizeof(struct H__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct H__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_size) == 130, "");
_Static_assert(_Alignof(struct H__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H_,b) == 0, "");
#endif
_Static_assert(sizeof(I) == 8, "");
_Static_assert(_Alignof(I) == 128, "");
_Static_assert(sizeof(struct I_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 128, "");
_Static_assert(sizeof(struct I_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 10, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 256, "");
_Static_assert(_Alignof(J) == 128, "");
_Static_assert(sizeof(struct J_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 128, "");
_Static_assert(sizeof(struct J_extra_packed) == 256, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 258, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,b) == 1024, "");
#endif
_Static_assert(sizeof(J_) == 128, "");
_Static_assert(_Alignof(J_) == 128, "");
_Static_assert(sizeof(struct J__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct J__extra_alignment) == 128, "");
_Static_assert(sizeof(struct J__extra_packed) == 128, "");
_Static_assert(_Alignof(struct J__extra_packed) == 1, "");
_Static_assert(sizeof(struct J__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct J__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J__extra_size) == 130, "");
_Static_assert(_Alignof(struct J__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J_,b) == 0, "");
#endif
// MAPPING|FOUR|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 2, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 4, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,b) == 8, "");
#endif
_Static_assert(sizeof(A_) == 1, "");
_Static_assert(_Alignof(A_) == 1, "");
_Static_assert(sizeof(struct A__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_packed) == 1, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 3, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,b) == 0, "");
#endif
_Static_assert(sizeof(B) == 2, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 2, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 4, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,b) == 8, "");
#endif
_Static_assert(sizeof(B_) == 1, "");
_Static_assert(_Alignof(B_) == 1, "");
_Static_assert(sizeof(struct B__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_packed) == 1, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 3, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,b) == 0, "");
#endif
_Static_assert(sizeof(C) == 2, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 2, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 4, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 8, "");
#endif
_Static_assert(sizeof(C_) == 1, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 1, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 3, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,b) == 0, "");
#endif
_Static_assert(sizeof(D) == 2, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 2, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 4, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,b) == 8, "");
#endif
_Static_assert(sizeof(D_) == 1, "");
_Static_assert(_Alignof(D_) == 1, "");
_Static_assert(sizeof(struct D__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D__extra_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_packed) == 1, "");
_Static_assert(_Alignof(struct D__extra_packed) == 1, "");
_Static_assert(sizeof(struct D__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_size) == 3, "");
_Static_assert(_Alignof(struct D__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D_,b) == 0, "");
#endif
_Static_assert(sizeof(E) == 256, "");
_Static_assert(_Alignof(E) == 128, "");
_Static_assert(sizeof(struct E_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 128, "");
_Static_assert(sizeof(struct E_extra_packed) == 256, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 258, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,b) == 1024, "");
#endif
_Static_assert(sizeof(E_) == 128, "");
_Static_assert(_Alignof(E_) == 128, "");
_Static_assert(sizeof(struct E__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct E__extra_alignment) == 128, "");
_Static_assert(sizeof(struct E__extra_packed) == 128, "");
_Static_assert(_Alignof(struct E__extra_packed) == 1, "");
_Static_assert(sizeof(struct E__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct E__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_size) == 130, "");
_Static_assert(_Alignof(struct E__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E_,b) == 0, "");
#endif
_Static_assert(sizeof(F) == 256, "");
_Static_assert(_Alignof(F) == 128, "");
_Static_assert(sizeof(struct F_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 128, "");
_Static_assert(sizeof(struct F_extra_packed) == 256, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 258, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,b) == 1024, "");
#endif
_Static_assert(sizeof(F_) == 128, "");
_Static_assert(_Alignof(F_) == 128, "");
_Static_assert(sizeof(struct F__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct F__extra_alignment) == 128, "");
_Static_assert(sizeof(struct F__extra_packed) == 128, "");
_Static_assert(_Alignof(struct F__extra_packed) == 1, "");
_Static_assert(sizeof(struct F__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct F__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_size) == 130, "");
_Static_assert(_Alignof(struct F__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F_,b) == 0, "");
#endif
_Static_assert(sizeof(G) == 256, "");
_Static_assert(_Alignof(G) == 128, "");
_Static_assert(sizeof(struct G_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 128, "");
_Static_assert(sizeof(struct G_extra_packed) == 256, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 258, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,b) == 1024, "");
#endif
_Static_assert(sizeof(G_) == 128, "");
_Static_assert(_Alignof(G_) == 128, "");
_Static_assert(sizeof(struct G__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct G__extra_alignment) == 128, "");
_Static_assert(sizeof(struct G__extra_packed) == 128, "");
_Static_assert(_Alignof(struct G__extra_packed) == 1, "");
_Static_assert(sizeof(struct G__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct G__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G__extra_size) == 130, "");
_Static_assert(_Alignof(struct G__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G_,b) == 0, "");
#endif
_Static_assert(sizeof(H) == 256, "");
_Static_assert(_Alignof(H) == 128, "");
_Static_assert(sizeof(struct H_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 128, "");
_Static_assert(sizeof(struct H_extra_packed) == 256, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 258, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,b) == 1024, "");
#endif
_Static_assert(sizeof(H_) == 128, "");
_Static_assert(_Alignof(H_) == 128, "");
_Static_assert(sizeof(struct H__extra_alignment) == 256, "");
_Static_assert(_Alignof(struct H__extra_alignment) == 128, "");
_Static_assert(sizeof(struct H__extra_packed) == 128, "");
_Static_assert(_Alignof(struct H__extra_packed) == 1, "");
_Static_assert(sizeof(struct H__extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct H__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_size) == 130, "");
_Static_assert(_Alignof(struct H__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H_,b) == 0, "");
#endif
_Static_assert(sizeof(I) == 8, "");
_Static_assert(_Alignof(I) == 128, "");
_Static_assert(sizeof(struct I_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 128, "");
_Static_assert(sizeof(struct I_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 10, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 2, "");
_Static_assert(_Alignof(J) == 1, "");
_Static_assert(sizeof(struct J_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_packed) == 2, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 4, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,b) == 8, "");
#endif
_Static_assert(sizeof(J_) == 1, "");
_Static_assert(_Alignof(J_) == 1, "");
_Static_assert(sizeof(struct J__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct J__extra_alignment) == 1, "");
_Static_assert(sizeof(struct J__extra_packed) == 1, "");
_Static_assert(_Alignof(struct J__extra_packed) == 1, "");
_Static_assert(sizeof(struct J__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct J__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J__extra_size) == 3, "");
_Static_assert(_Alignof(struct J__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J_,b) == 0, "");
#endif
// MAPPING|FIVE|x86-pentium4-ios-none:Clang|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets I386AppleIos|Some("x86-pentium4-ios-none") I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 8, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 10, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,b) == 32, "");
#endif
_Static_assert(sizeof(A_) == 4, "");
_Static_assert(_Alignof(A_) == 4, "");
_Static_assert(sizeof(struct A__extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 4, "");
_Static_assert(sizeof(struct A__extra_packed) == 4, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 6, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,b) == 0, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,b) == 32, "");
#endif
_Static_assert(sizeof(B_) == 4, "");
_Static_assert(_Alignof(B_) == 4, "");
_Static_assert(sizeof(struct B__extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 4, "");
_Static_assert(sizeof(struct B__extra_packed) == 4, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 6, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,b) == 0, "");
#endif
_Static_assert(sizeof(C) == 5, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 5, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 7, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 32, "");
#endif
_Static_assert(sizeof(C_) == 1, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 1, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 3, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,b) == 0, "");
#endif
_Static_assert(sizeof(D) == 5, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 5, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 7, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,b) == 32, "");
#endif
_Static_assert(sizeof(D_) == 1, "");
_Static_assert(_Alignof(D_) == 1, "");
_Static_assert(sizeof(struct D__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D__extra_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_packed) == 1, "");
_Static_assert(_Alignof(struct D__extra_packed) == 1, "");
_Static_assert(sizeof(struct D__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_size) == 3, "");
_Static_assert(_Alignof(struct D__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D_,b) == 0, "");
#endif
_Static_assert(sizeof(E) == 129, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 129, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 131, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,b) == 1024, "");
#endif
_Static_assert(sizeof(E_) == 1, "");
_Static_assert(_Alignof(E_) == 1, "");
_Static_assert(sizeof(struct E__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E__extra_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_packed) == 1, "");
_Static_assert(_Alignof(struct E__extra_packed) == 1, "");
_Static_assert(sizeof(struct E__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_size) == 3, "");
_Static_assert(_Alignof(struct E__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E_,b) == 0, "");
#endif
_Static_assert(sizeof(F) == 129, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 129, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 131, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,b) == 1024, "");
#endif
_Static_assert(sizeof(F_) == 1, "");
_Static_assert(_Alignof(F_) == 1, "");
_Static_assert(sizeof(struct F__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F__extra_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_packed) == 1, "");
_Static_assert(_Alignof(struct F__extra_packed) == 1, "");
_Static_assert(sizeof(struct F__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_size) == 3, "");
_Static_assert(_Alignof(struct F__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F_,b) == 0, "");
#endif
_Static_assert(sizeof(G) == 132, "");
_Static_assert(_Alignof(G) == 4, "");
_Static_assert(sizeof(struct G_extra_alignment) == 136, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 4, "");
_Static_assert(sizeof(struct G_extra_packed) == 132, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 133, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 134, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,b) == 1024, "");
#endif
_Static_assert(sizeof(G_) == 4, "");
_Static_assert(_Alignof(G_) == 4, "");
_Static_assert(sizeof(struct G__extra_alignment) == 8, "");
_Static_assert(_Alignof(struct G__extra_alignment) == 4, "");
_Static_assert(sizeof(struct G__extra_packed) == 4, "");
_Static_assert(_Alignof(struct G__extra_packed) == 1, "");
_Static_assert(sizeof(struct G__extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct G__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G__extra_size) == 6, "");
_Static_assert(_Alignof(struct G__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G_,b) == 0, "");
#endif
_Static_assert(sizeof(H) == 129, "");
_Static_assert(_Alignof(H) == 1, "");
_Static_assert(sizeof(struct H_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_packed) == 129, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 131, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,b) == 1024, "");
#endif
_Static_assert(sizeof(H_) == 1, "");
_Static_assert(_Alignof(H_) == 1, "");
_Static_assert(sizeof(struct H__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct H__extra_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_packed) == 1, "");
_Static_assert(_Alignof(struct H__extra_packed) == 1, "");
_Static_assert(sizeof(struct H__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct H__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_size) == 3, "");
_Static_assert(_Alignof(struct H__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H_,b) == 0, "");
#endif
_Static_assert(sizeof(I) == 8, "");
_Static_assert(_Alignof(I) == 128, "");
_Static_assert(sizeof(struct I_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 128, "");
_Static_assert(sizeof(struct I_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 10, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 132, "");
_Static_assert(_Alignof(J) == 4, "");
_Static_assert(sizeof(struct J_extra_alignment) == 136, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 4, "");
_Static_assert(sizeof(struct J_extra_packed) == 132, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 133, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 134, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,b) == 1024, "");
#endif
_Static_assert(sizeof(J_) == 4, "");
_Static_assert(_Alignof(J_) == 4, "");
_Static_assert(sizeof(struct J__extra_alignment) == 8, "");
_Static_assert(_Alignof(struct J__extra_alignment) == 4, "");
_Static_assert(sizeof(struct J__extra_packed) == 4, "");
_Static_assert(_Alignof(struct J__extra_packed) == 1, "");
_Static_assert(sizeof(struct J__extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct J__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J__extra_size) == 6, "");
_Static_assert(_Alignof(struct J__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J_,b) == 0, "");
#endif
// MAPPING|SIX|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(SIX)
_Static_assert(sizeof(A) == 16, "");
_Static_assert(_Alignof(A) == 8, "");
_Static_assert(sizeof(struct A_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 18, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,b) == 64, "");
#endif
_Static_assert(sizeof(A_) == 8, "");
_Static_assert(_Alignof(A_) == 8, "");
_Static_assert(sizeof(struct A__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 8, "");
_Static_assert(sizeof(struct A__extra_packed) == 8, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 10, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,b) == 0, "");
#endif
_Static_assert(sizeof(B) == 16, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 16, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 18, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,b) == 64, "");
#endif
_Static_assert(sizeof(B_) == 8, "");
_Static_assert(_Alignof(B_) == 8, "");
_Static_assert(sizeof(struct B__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 8, "");
_Static_assert(sizeof(struct B__extra_packed) == 8, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 10, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,b) == 0, "");
#endif
_Static_assert(sizeof(C) == 16, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 16, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 18, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 64, "");
#endif
_Static_assert(sizeof(C_) == 1, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 1, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 3, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,b) == 0, "");
#endif
_Static_assert(sizeof(D) == 16, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 17, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 18, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,b) == 64, "");
#endif
_Static_assert(sizeof(D_) == 1, "");
_Static_assert(_Alignof(D_) == 1, "");
_Static_assert(sizeof(struct D__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D__extra_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_packed) == 1, "");
_Static_assert(_Alignof(struct D__extra_packed) == 1, "");
_Static_assert(sizeof(struct D__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_size) == 3, "");
_Static_assert(_Alignof(struct D__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D_,b) == 0, "");
#endif
_Static_assert(sizeof(E) == 16, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 17, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 16, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 18, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,b) == 64, "");
#endif
_Static_assert(sizeof(E_) == 1, "");
_Static_assert(_Alignof(E_) == 1, "");
_Static_assert(sizeof(struct E__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E__extra_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_packed) == 1, "");
_Static_assert(_Alignof(struct E__extra_packed) == 1, "");
_Static_assert(sizeof(struct E__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_size) == 3, "");
_Static_assert(_Alignof(struct E__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E_,b) == 0, "");
#endif
_Static_assert(sizeof(F) == 256, "");
_Static_assert(_Alignof(F) == 128, "");
_Static_assert(sizeof(struct F_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 128, "");
_Static_assert(sizeof(struct F_extra_packed) == 256, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 258, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,b) == 1024, "");
#endif
_Static_assert(sizeof(F_) == 1, "");
_Static_assert(_Alignof(F_) == 1, "");
_Static_assert(sizeof(struct F__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F__extra_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_packed) == 1, "");
_Static_assert(_Alignof(struct F__extra_packed) == 1, "");
_Static_assert(sizeof(struct F__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_size) == 3, "");
_Static_assert(_Alignof(struct F__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F_,b) == 0, "");
#endif
_Static_assert(sizeof(G) == 256, "");
_Static_assert(_Alignof(G) == 128, "");
_Static_assert(sizeof(struct G_extra_alignment) == 384, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 128, "");
_Static_assert(sizeof(struct G_extra_packed) == 256, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 257, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 258, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,b) == 1024, "");
#endif
_Static_assert(sizeof(G_) == 8, "");
_Static_assert(_Alignof(G_) == 8, "");
_Static_assert(sizeof(struct G__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct G__extra_alignment) == 8, "");
_Static_assert(sizeof(struct G__extra_packed) == 8, "");
_Static_assert(_Alignof(struct G__extra_packed) == 1, "");
_Static_assert(sizeof(struct G__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G__extra_size) == 10, "");
_Static_assert(_Alignof(struct G__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G_,b) == 0, "");
#endif
_Static_assert(sizeof(H) == 16, "");
_Static_assert(_Alignof(H) == 1, "");
_Static_assert(sizeof(struct H_extra_alignment) == 17, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_packed) == 16, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 18, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,b) == 64, "");
#endif
_Static_assert(sizeof(H_) == 1, "");
_Static_assert(_Alignof(H_) == 1, "");
_Static_assert(sizeof(struct H__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct H__extra_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_packed) == 1, "");
_Static_assert(_Alignof(struct H__extra_packed) == 1, "");
_Static_assert(sizeof(struct H__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct H__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_size) == 3, "");
_Static_assert(_Alignof(struct H__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H_,b) == 0, "");
#endif
_Static_assert(sizeof(I) == 8, "");
_Static_assert(_Alignof(I) == 128, "");
_Static_assert(sizeof(struct I_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 128, "");
_Static_assert(sizeof(struct I_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 10, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 128, "");
_Static_assert(_Alignof(J) == 128, "");
_Static_assert(sizeof(struct J_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 128, "");
_Static_assert(sizeof(struct J_extra_packed) == 128, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 129, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 130, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,b) == 64, "");
#endif
_Static_assert(sizeof(J_) == 8, "");
_Static_assert(_Alignof(J_) == 8, "");
_Static_assert(sizeof(struct J__extra_alignment) == 16, "");
_Static_assert(_Alignof(struct J__extra_alignment) == 8, "");
_Static_assert(sizeof(struct J__extra_packed) == 8, "");
_Static_assert(_Alignof(struct J__extra_packed) == 1, "");
_Static_assert(sizeof(struct J__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J__extra_size) == 10, "");
_Static_assert(_Alignof(struct J__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J_,b) == 0, "");
#endif
// MAPPING|SEVEN|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(SEVEN)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 2, "");
_Static_assert(sizeof(struct A_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,b) == 16, "");
#endif
_Static_assert(sizeof(A_) == 2, "");
_Static_assert(_Alignof(A_) == 2, "");
_Static_assert(sizeof(struct A__extra_alignment) == 4, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 2, "");
_Static_assert(sizeof(struct A__extra_packed) == 2, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 4, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,b) == 0, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 2, "");
_Static_assert(sizeof(struct B_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 2, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,b) == 16, "");
#endif
_Static_assert(sizeof(B_) == 2, "");
_Static_assert(_Alignof(B_) == 2, "");
_Static_assert(sizeof(struct B__extra_alignment) == 4, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 2, "");
_Static_assert(sizeof(struct B__extra_packed) == 2, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 4, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,b) == 0, "");
#endif
_Static_assert(sizeof(C) == 3, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 3, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 5, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,b) == 16, "");
#endif
_Static_assert(sizeof(C_) == 1, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 1, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 3, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,b) == 0, "");
#endif
_Static_assert(sizeof(D) == 3, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 3, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 5, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,b) == 16, "");
#endif
_Static_assert(sizeof(D_) == 1, "");
_Static_assert(_Alignof(D_) == 1, "");
_Static_assert(sizeof(struct D__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct D__extra_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_packed) == 1, "");
_Static_assert(_Alignof(struct D__extra_packed) == 1, "");
_Static_assert(sizeof(struct D__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct D__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D__extra_size) == 3, "");
_Static_assert(_Alignof(struct D__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D_,b) == 0, "");
#endif
_Static_assert(sizeof(E) == 129, "");
_Static_assert(_Alignof(E) == 1, "");
_Static_assert(sizeof(struct E_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct E_extra_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_packed) == 129, "");
_Static_assert(_Alignof(struct E_extra_packed) == 1, "");
_Static_assert(sizeof(struct E_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct E_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E_extra_size) == 131, "");
_Static_assert(_Alignof(struct E_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E,b) == 1024, "");
#endif
_Static_assert(sizeof(E_) == 1, "");
_Static_assert(_Alignof(E_) == 1, "");
_Static_assert(sizeof(struct E__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct E__extra_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_packed) == 1, "");
_Static_assert(_Alignof(struct E__extra_packed) == 1, "");
_Static_assert(sizeof(struct E__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct E__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct E__extra_size) == 3, "");
_Static_assert(_Alignof(struct E__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(E_,b) == 0, "");
#endif
_Static_assert(sizeof(F) == 129, "");
_Static_assert(_Alignof(F) == 1, "");
_Static_assert(sizeof(struct F_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_packed) == 129, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 131, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,b) == 1024, "");
#endif
_Static_assert(sizeof(F_) == 1, "");
_Static_assert(_Alignof(F_) == 1, "");
_Static_assert(sizeof(struct F__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct F__extra_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_packed) == 1, "");
_Static_assert(_Alignof(struct F__extra_packed) == 1, "");
_Static_assert(sizeof(struct F__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct F__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F__extra_size) == 3, "");
_Static_assert(_Alignof(struct F__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F_,b) == 0, "");
#endif
_Static_assert(sizeof(G) == 130, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 130, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 131, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 132, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,b) == 1024, "");
#endif
_Static_assert(sizeof(G_) == 2, "");
_Static_assert(_Alignof(G_) == 2, "");
_Static_assert(sizeof(struct G__extra_alignment) == 4, "");
_Static_assert(_Alignof(struct G__extra_alignment) == 2, "");
_Static_assert(sizeof(struct G__extra_packed) == 2, "");
_Static_assert(_Alignof(struct G__extra_packed) == 1, "");
_Static_assert(sizeof(struct G__extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct G__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G__extra_size) == 4, "");
_Static_assert(_Alignof(struct G__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G_,b) == 0, "");
#endif
_Static_assert(sizeof(H) == 129, "");
_Static_assert(_Alignof(H) == 1, "");
_Static_assert(sizeof(struct H_extra_alignment) == 130, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_packed) == 129, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 130, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 131, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,b) == 1024, "");
#endif
_Static_assert(sizeof(H_) == 1, "");
_Static_assert(_Alignof(H_) == 1, "");
_Static_assert(sizeof(struct H__extra_alignment) == 2, "");
_Static_assert(_Alignof(struct H__extra_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_packed) == 1, "");
_Static_assert(_Alignof(struct H__extra_packed) == 1, "");
_Static_assert(sizeof(struct H__extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct H__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H__extra_size) == 3, "");
_Static_assert(_Alignof(struct H__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H_,b) == 0, "");
#endif
_Static_assert(sizeof(I) == 8, "");
_Static_assert(_Alignof(I) == 128, "");
_Static_assert(sizeof(struct I_extra_alignment) == 256, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 128, "");
_Static_assert(sizeof(struct I_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 10, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
_Static_assert(sizeof(J) == 130, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 132, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 130, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 131, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 132, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,b) == 1024, "");
#endif
_Static_assert(sizeof(J_) == 2, "");
_Static_assert(_Alignof(J_) == 2, "");
_Static_assert(sizeof(struct J__extra_alignment) == 4, "");
_Static_assert(_Alignof(struct J__extra_alignment) == 2, "");
_Static_assert(sizeof(struct J__extra_packed) == 2, "");
_Static_assert(_Alignof(struct J__extra_packed) == 1, "");
_Static_assert(sizeof(struct J__extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct J__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J__extra_size) == 4, "");
_Static_assert(_Alignof(struct J__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J_,b) == 0, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0017_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
#ifdef MSVC
__declspec(align(4)) typedef char A;
#else
typedef char A __attribute__((aligned(4)));
#endif
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
#ifdef MSVC
char a[sizeof(A)];
#else
A a;
#endif
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef A B[3];
B var5;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var6;
#pragma pack(1)
struct B_extra_packed {
#ifdef MSVC
char a[sizeof(B)];
#else
B a;
#endif
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var7;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-ios-none:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-baseline-ios-none:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-netbsd-eabihf:Clang|hexagon-generic-linux-musl:Clang|x86-pentium4-ios-none:Clang|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|mipsel-mips32-other-none:Clang|msp430-msp430-other-eabi:Clang|powerpc64-ppc64-freebsd-gnu:Clang|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|riscv64-baseline_rv64-other-eabi:Clang|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7sAppleIos|Some("arm-baseline-ios-none") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") I386AppleIos|Some("x86-pentium4-ios-none") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu") MipselSonyPsp|None MipselUnknownNone|Some("mipsel-mips32-other-none") Msp430NoneElf|Some("msp430-msp430-other-eabi") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
// MAPPING|TWO|aarch64-generic-windows-msvc:Msvc|x86-i586-windows-msvc:Msvc|x86-i686-windows-msvc:Msvc|x86-i686-uefi-msvc:Msvc|thumb-baseline-windows-msvc:Msvc|x86_64-x86_64-windows-msvc:Msvc|x86_64-x86_64-uefi-msvc:Msvc|END
// repr targets Aarch64PcWindowsMsvc|Some("aarch64-generic-windows-msvc") I586PcWindowsMsvc|Some("x86-i586-windows-msvc") I686PcWindowsMsvc|Some("x86-i686-windows-msvc") I686UnknownWindows|Some("x86-i686-uefi-msvc") Thumbv7aPcWindowsMsvc|Some("thumb-baseline-windows-msvc") X86_64PcWindowsMsvc|Some("x86_64-x86_64-windows-msvc") X86_64UnknownWindows|Some("x86_64-x86_64-uefi-msvc")
#elif defined(TWO)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
_Static_assert(sizeof(B) == 3, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 3, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 5, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0068_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef struct {
char:0 __attribute__((aligned(4)));
char d;
} A;
A var1;
struct A_extra_alignment {
char a;
A b;
};
struct A_extra_alignment var2;
#pragma pack(1)
struct A_extra_packed {
A a;
};
#pragma pack()
struct A_extra_required_alignment {
char a;
struct A_extra_packed b;
};
struct A_extra_required_alignment var3;
struct A_extra_size {
char a[sizeof(A)+1];
char b;
};
struct A_extra_size var4;
typedef struct {
char c;
char:0 __attribute__((aligned(4)));
char d;
} A_;
A_ var5;
struct A__extra_alignment {
char a;
A_ b;
};
struct A__extra_alignment var6;
#pragma pack(1)
struct A__extra_packed {
A_ a;
};
#pragma pack()
struct A__extra_required_alignment {
char a;
struct A__extra_packed b;
};
struct A__extra_required_alignment var7;
struct A__extra_size {
char a[sizeof(A_)+1];
char b;
};
struct A__extra_size var8;
typedef struct {
long long:0 __attribute__((aligned(4)));
char d;
} B;
B var9;
struct B_extra_alignment {
char a;
B b;
};
struct B_extra_alignment var10;
#pragma pack(1)
struct B_extra_packed {
B a;
};
#pragma pack()
struct B_extra_required_alignment {
char a;
struct B_extra_packed b;
};
struct B_extra_required_alignment var11;
struct B_extra_size {
char a[sizeof(B)+1];
char b;
};
struct B_extra_size var12;
typedef struct {
char c;
long long:0 __attribute__((aligned(4)));
char d;
} B_;
B_ var13;
struct B__extra_alignment {
char a;
B_ b;
};
struct B__extra_alignment var14;
#pragma pack(1)
struct B__extra_packed {
B_ a;
};
#pragma pack()
struct B__extra_required_alignment {
char a;
struct B__extra_packed b;
};
struct B__extra_required_alignment var15;
struct B__extra_size {
char a[sizeof(B_)+1];
char b;
};
struct B__extra_size var16;
typedef struct {
long long:0;
char d;
} C;
C var17;
struct C_extra_alignment {
char a;
C b;
};
struct C_extra_alignment var18;
#pragma pack(1)
struct C_extra_packed {
C a;
};
#pragma pack()
struct C_extra_required_alignment {
char a;
struct C_extra_packed b;
};
struct C_extra_required_alignment var19;
struct C_extra_size {
char a[sizeof(C)+1];
char b;
};
struct C_extra_size var20;
typedef struct {
char c;
long long:0;
char d;
} C_;
C_ var21;
struct C__extra_alignment {
char a;
C_ b;
};
struct C__extra_alignment var22;
#pragma pack(1)
struct C__extra_packed {
C_ a;
};
#pragma pack()
struct C__extra_required_alignment {
char a;
struct C__extra_packed b;
};
struct C__extra_required_alignment var23;
struct C__extra_size {
char a[sizeof(C_)+1];
char b;
};
struct C__extra_size var24;
typedef struct {
char c;
long long d;
char e;
} D;
D var25;
struct D_extra_alignment {
char a;
D b;
};
struct D_extra_alignment var26;
#pragma pack(1)
struct D_extra_packed {
D a;
};
#pragma pack()
struct D_extra_required_alignment {
char a;
struct D_extra_packed b;
};
struct D_extra_required_alignment var27;
struct D_extra_size {
char a[sizeof(D)+1];
char b;
};
struct D_extra_size var28;
typedef struct {
char c;
long long d __attribute__((aligned(16)));
char e;
} F;
F var29;
struct F_extra_alignment {
char a;
F b;
};
struct F_extra_alignment var30;
#pragma pack(1)
struct F_extra_packed {
F a;
};
#pragma pack()
struct F_extra_required_alignment {
char a;
struct F_extra_packed b;
};
struct F_extra_required_alignment var31;
struct F_extra_size {
char a[sizeof(F)+1];
char b;
};
struct F_extra_size var32;
typedef struct {
char c;
long long d __attribute__((aligned(2))) __attribute__((packed));
char e;
} G;
G var33;
struct G_extra_alignment {
char a;
G b;
};
struct G_extra_alignment var34;
#pragma pack(1)
struct G_extra_packed {
G a;
};
#pragma pack()
struct G_extra_required_alignment {
char a;
struct G_extra_packed b;
};
struct G_extra_required_alignment var35;
struct G_extra_size {
char a[sizeof(G)+1];
char b;
};
struct G_extra_size var36;
#pragma pack(2)
typedef struct {
char c;
long long d __attribute__((aligned(4))) __attribute__((packed));
char e;
} H;
H var37;
#pragma pack()
struct H_extra_alignment {
char a;
H b;
};
struct H_extra_alignment var38;
#pragma pack(1)
struct H_extra_packed {
H a;
};
#pragma pack()
struct H_extra_required_alignment {
char a;
struct H_extra_packed b;
};
struct H_extra_required_alignment var39;
struct H_extra_size {
char a[sizeof(H)+1];
char b;
};
struct H_extra_size var40;
typedef struct {
char c;
long long d __attribute__((packed));
char e;
} I;
I var41;
struct I_extra_alignment {
char a;
I b;
};
struct I_extra_alignment var42;
#pragma pack(1)
struct I_extra_packed {
I a;
};
#pragma pack()
struct I_extra_required_alignment {
char a;
struct I_extra_packed b;
};
struct I_extra_required_alignment var43;
struct I_extra_size {
char a[sizeof(I)+1];
char b;
};
struct I_extra_size var44;
#pragma pack(2)
typedef struct {
char c;
long long d;
char e;
} J;
J var45;
#pragma pack()
struct J_extra_alignment {
char a;
J b;
};
struct J_extra_alignment var46;
#pragma pack(1)
struct J_extra_packed {
J a;
};
#pragma pack()
struct J_extra_required_alignment {
char a;
struct J_extra_packed b;
};
struct J_extra_required_alignment var47;
struct J_extra_size {
char a[sizeof(J)+1];
char b;
};
struct J_extra_size var48;
typedef struct {
char c;
long long d:1;
char e;
} K;
K var49;
struct K_extra_alignment {
char a;
K b;
};
struct K_extra_alignment var50;
#pragma pack(1)
struct K_extra_packed {
K a;
};
#pragma pack()
struct K_extra_required_alignment {
char a;
struct K_extra_packed b;
};
struct K_extra_required_alignment var51;
struct K_extra_size {
char a[sizeof(K)+1];
char b;
};
struct K_extra_size var52;
typedef struct {
char c;
long long d:1 __attribute__((aligned(16)));
char e;
} L;
L var53;
struct L_extra_alignment {
char a;
L b;
};
struct L_extra_alignment var54;
#pragma pack(1)
struct L_extra_packed {
L a;
};
#pragma pack()
struct L_extra_required_alignment {
char a;
struct L_extra_packed b;
};
struct L_extra_required_alignment var55;
struct L_extra_size {
char a[sizeof(L)+1];
char b;
};
struct L_extra_size var56;
typedef struct {
char c;
long long d:1 __attribute__((aligned(2))) __attribute__((packed));
char e;
} M;
M var57;
struct M_extra_alignment {
char a;
M b;
};
struct M_extra_alignment var58;
#pragma pack(1)
struct M_extra_packed {
M a;
};
#pragma pack()
struct M_extra_required_alignment {
char a;
struct M_extra_packed b;
};
struct M_extra_required_alignment var59;
struct M_extra_size {
char a[sizeof(M)+1];
char b;
};
struct M_extra_size var60;
#pragma pack(2)
typedef struct {
char c;
long long d:1 __attribute__((aligned(4))) __attribute__((packed));
char e;
} N;
N var61;
#pragma pack()
struct N_extra_alignment {
char a;
N b;
};
struct N_extra_alignment var62;
#pragma pack(1)
struct N_extra_packed {
N a;
};
#pragma pack()
struct N_extra_required_alignment {
char a;
struct N_extra_packed b;
};
struct N_extra_required_alignment var63;
struct N_extra_size {
char a[sizeof(N)+1];
char b;
};
struct N_extra_size var64;
typedef struct {
char c;
long long d:1 __attribute__((packed));
char e;
} O;
O var65;
struct O_extra_alignment {
char a;
O b;
};
struct O_extra_alignment var66;
#pragma pack(1)
struct O_extra_packed {
O a;
};
#pragma pack()
struct O_extra_required_alignment {
char a;
struct O_extra_packed b;
};
struct O_extra_required_alignment var67;
struct O_extra_size {
char a[sizeof(O)+1];
char b;
};
struct O_extra_size var68;
#pragma pack(2)
typedef struct {
char c;
long long d:1;
char e;
} P;
P var69;
#pragma pack()
struct P_extra_alignment {
char a;
P b;
};
struct P_extra_alignment var70;
#pragma pack(1)
struct P_extra_packed {
P a;
};
#pragma pack()
struct P_extra_required_alignment {
char a;
struct P_extra_packed b;
};
struct P_extra_required_alignment var71;
struct P_extra_size {
char a[sizeof(P)+1];
char b;
};
struct P_extra_size var72;
typedef struct {
char c;
char x:1;
long long d:1;
char e;
} Q;
Q var73;
struct Q_extra_alignment {
char a;
Q b;
};
struct Q_extra_alignment var74;
#pragma pack(1)
struct Q_extra_packed {
Q a;
};
#pragma pack()
struct Q_extra_required_alignment {
char a;
struct Q_extra_packed b;
};
struct Q_extra_required_alignment var75;
struct Q_extra_size {
char a[sizeof(Q)+1];
char b;
};
struct Q_extra_size var76;
typedef struct {
char c;
char x:1;
long long:0 __attribute__((aligned(16)));
char e;
} R;
R var77;
struct R_extra_alignment {
char a;
R b;
};
struct R_extra_alignment var78;
#pragma pack(1)
struct R_extra_packed {
R a;
};
#pragma pack()
struct R_extra_required_alignment {
char a;
struct R_extra_packed b;
};
struct R_extra_required_alignment var79;
struct R_extra_size {
char a[sizeof(R)+1];
char b;
};
struct R_extra_size var80;
typedef struct {
char c;
char x:1;
long long:0 __attribute__((aligned(2))) __attribute__((packed));
char e;
} S;
S var81;
struct S_extra_alignment {
char a;
S b;
};
struct S_extra_alignment var82;
#pragma pack(1)
struct S_extra_packed {
S a;
};
#pragma pack()
struct S_extra_required_alignment {
char a;
struct S_extra_packed b;
};
struct S_extra_required_alignment var83;
struct S_extra_size {
char a[sizeof(S)+1];
char b;
};
struct S_extra_size var84;
#pragma pack(2)
typedef struct {
char c;
char x:1;
long long:0 __attribute__((aligned(4))) __attribute__((packed));
char e;
} T;
T var85;
#pragma pack()
struct T_extra_alignment {
char a;
T b;
};
struct T_extra_alignment var86;
#pragma pack(1)
struct T_extra_packed {
T a;
};
#pragma pack()
struct T_extra_required_alignment {
char a;
struct T_extra_packed b;
};
struct T_extra_required_alignment var87;
struct T_extra_size {
char a[sizeof(T)+1];
char b;
};
struct T_extra_size var88;
typedef struct {
char c;
char x:1;
long long:0 __attribute__((packed));
char e;
} U;
U var89;
struct U_extra_alignment {
char a;
U b;
};
struct U_extra_alignment var90;
#pragma pack(1)
struct U_extra_packed {
U a;
};
#pragma pack()
struct U_extra_required_alignment {
char a;
struct U_extra_packed b;
};
struct U_extra_required_alignment var91;
struct U_extra_size {
char a[sizeof(U)+1];
char b;
};
struct U_extra_size var92;
#pragma pack(2)
typedef struct {
char c;
char x:1;
long long:0;
char e;
} V;
V var93;
#pragma pack()
struct V_extra_alignment {
char a;
V b;
};
struct V_extra_alignment var94;
#pragma pack(1)
struct V_extra_packed {
V a;
};
#pragma pack()
struct V_extra_required_alignment {
char a;
struct V_extra_packed b;
};
struct V_extra_required_alignment var95;
struct V_extra_size {
char a[sizeof(V)+1];
char b;
};
struct V_extra_size var96;
typedef struct {
char c;
char x:1;
long long:0 __attribute__((aligned(16))) __attribute__((packed));
char e;
} W;
W var97;
struct W_extra_alignment {
char a;
W b;
};
struct W_extra_alignment var98;
#pragma pack(1)
struct W_extra_packed {
W a;
};
#pragma pack()
struct W_extra_required_alignment {
char a;
struct W_extra_packed b;
};
struct W_extra_required_alignment var99;
struct W_extra_size {
char a[sizeof(W)+1];
char b;
};
struct W_extra_size var100;
#pragma pack(1)
typedef struct {
char c;
long long:0 __attribute__((aligned(16)));
char e;
} W_;
W_ var101;
#pragma pack()
struct W__extra_alignment {
char a;
W_ b;
};
struct W__extra_alignment var102;
#pragma pack(1)
struct W__extra_packed {
W_ a;
};
#pragma pack()
struct W__extra_required_alignment {
char a;
struct W__extra_packed b;
};
struct W__extra_required_alignment var103;
struct W__extra_size {
char a[sizeof(W_)+1];
char b;
};
struct W__extra_size var104;
#pragma pack(2)
typedef struct {
char c;
char x:1;
long long:0 __attribute__((aligned(16))) __attribute__((packed));
char e;
} X;
X var105;
#pragma pack()
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var106;
#pragma pack(1)
struct X_extra_packed {
X a;
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var107;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var108;
typedef union {
char:0 __attribute__((aligned(4)));
char d;
} A2;
A2 var109;
struct A2_extra_alignment {
char a;
A2 b;
};
struct A2_extra_alignment var110;
#pragma pack(1)
struct A2_extra_packed {
A2 a;
};
#pragma pack()
struct A2_extra_required_alignment {
char a;
struct A2_extra_packed b;
};
struct A2_extra_required_alignment var111;
struct A2_extra_size {
char a[sizeof(A2)+1];
char b;
};
struct A2_extra_size var112;
typedef union {
char c;
char:0 __attribute__((aligned(4)));
char d;
} A_2;
A_2 var113;
struct A_2_extra_alignment {
char a;
A_2 b;
};
struct A_2_extra_alignment var114;
#pragma pack(1)
struct A_2_extra_packed {
A_2 a;
};
#pragma pack()
struct A_2_extra_required_alignment {
char a;
struct A_2_extra_packed b;
};
struct A_2_extra_required_alignment var115;
struct A_2_extra_size {
char a[sizeof(A_2)+1];
char b;
};
struct A_2_extra_size var116;
typedef union {
long long:0 __attribute__((aligned(4)));
char d;
} B2;
B2 var117;
struct B2_extra_alignment {
char a;
B2 b;
};
struct B2_extra_alignment var118;
#pragma pack(1)
struct B2_extra_packed {
B2 a;
};
#pragma pack()
struct B2_extra_required_alignment {
char a;
struct B2_extra_packed b;
};
struct B2_extra_required_alignment var119;
struct B2_extra_size {
char a[sizeof(B2)+1];
char b;
};
struct B2_extra_size var120;
typedef union {
char c;
long long:0 __attribute__((aligned(4)));
char d;
} B_2;
B_2 var121;
struct B_2_extra_alignment {
char a;
B_2 b;
};
struct B_2_extra_alignment var122;
#pragma pack(1)
struct B_2_extra_packed {
B_2 a;
};
#pragma pack()
struct B_2_extra_required_alignment {
char a;
struct B_2_extra_packed b;
};
struct B_2_extra_required_alignment var123;
struct B_2_extra_size {
char a[sizeof(B_2)+1];
char b;
};
struct B_2_extra_size var124;
typedef union {
long long:0;
char d;
} C2;
C2 var125;
struct C2_extra_alignment {
char a;
C2 b;
};
struct C2_extra_alignment var126;
#pragma pack(1)
struct C2_extra_packed {
C2 a;
};
#pragma pack()
struct C2_extra_required_alignment {
char a;
struct C2_extra_packed b;
};
struct C2_extra_required_alignment var127;
struct C2_extra_size {
char a[sizeof(C2)+1];
char b;
};
struct C2_extra_size var128;
typedef union {
char c;
long long:0;
char d;
} C22;
C22 var129;
struct C22_extra_alignment {
char a;
C22 b;
};
struct C22_extra_alignment var130;
#pragma pack(1)
struct C22_extra_packed {
C22 a;
};
#pragma pack()
struct C22_extra_required_alignment {
char a;
struct C22_extra_packed b;
};
struct C22_extra_required_alignment var131;
struct C22_extra_size {
char a[sizeof(C22)+1];
char b;
};
struct C22_extra_size var132;
typedef union {
char c;
long long d;
char e;
} D2;
D2 var133;
struct D2_extra_alignment {
char a;
D2 b;
};
struct D2_extra_alignment var134;
#pragma pack(1)
struct D2_extra_packed {
D2 a;
};
#pragma pack()
struct D2_extra_required_alignment {
char a;
struct D2_extra_packed b;
};
struct D2_extra_required_alignment var135;
struct D2_extra_size {
char a[sizeof(D2)+1];
char b;
};
struct D2_extra_size var136;
typedef union {
char c;
long long d __attribute__((aligned(16)));
char e;
} F2;
F2 var137;
struct F2_extra_alignment {
char a;
F2 b;
};
struct F2_extra_alignment var138;
#pragma pack(1)
struct F2_extra_packed {
F2 a;
};
#pragma pack()
struct F2_extra_required_alignment {
char a;
struct F2_extra_packed b;
};
struct F2_extra_required_alignment var139;
struct F2_extra_size {
char a[sizeof(F2)+1];
char b;
};
struct F2_extra_size var140;
typedef union {
char c;
long long d __attribute__((aligned(2))) __attribute__((packed));
char e;
} G2;
G2 var141;
struct G2_extra_alignment {
char a;
G2 b;
};
struct G2_extra_alignment var142;
#pragma pack(1)
struct G2_extra_packed {
G2 a;
};
#pragma pack()
struct G2_extra_required_alignment {
char a;
struct G2_extra_packed b;
};
struct G2_extra_required_alignment var143;
struct G2_extra_size {
char a[sizeof(G2)+1];
char b;
};
struct G2_extra_size var144;
#pragma pack(2)
typedef union {
char c;
long long d __attribute__((aligned(4))) __attribute__((packed));
char e;
} H2;
H2 var145;
#pragma pack()
struct H2_extra_alignment {
char a;
H2 b;
};
struct H2_extra_alignment var146;
#pragma pack(1)
struct H2_extra_packed {
H2 a;
};
#pragma pack()
struct H2_extra_required_alignment {
char a;
struct H2_extra_packed b;
};
struct H2_extra_required_alignment var147;
struct H2_extra_size {
char a[sizeof(H2)+1];
char b;
};
struct H2_extra_size var148;
typedef union {
char c;
long long d __attribute__((packed));
char e;
} I2;
I2 var149;
struct I2_extra_alignment {
char a;
I2 b;
};
struct I2_extra_alignment var150;
#pragma pack(1)
struct I2_extra_packed {
I2 a;
};
#pragma pack()
struct I2_extra_required_alignment {
char a;
struct I2_extra_packed b;
};
struct I2_extra_required_alignment var151;
struct I2_extra_size {
char a[sizeof(I2)+1];
char b;
};
struct I2_extra_size var152;
#pragma pack(2)
typedef union {
char c;
long long d;
char e;
} J2;
J2 var153;
#pragma pack()
struct J2_extra_alignment {
char a;
J2 b;
};
struct J2_extra_alignment var154;
#pragma pack(1)
struct J2_extra_packed {
J2 a;
};
#pragma pack()
struct J2_extra_required_alignment {
char a;
struct J2_extra_packed b;
};
struct J2_extra_required_alignment var155;
struct J2_extra_size {
char a[sizeof(J2)+1];
char b;
};
struct J2_extra_size var156;
typedef union {
char c;
long long d:1;
char e;
} K2;
K2 var157;
struct K2_extra_alignment {
char a;
K2 b;
};
struct K2_extra_alignment var158;
#pragma pack(1)
struct K2_extra_packed {
K2 a;
};
#pragma pack()
struct K2_extra_required_alignment {
char a;
struct K2_extra_packed b;
};
struct K2_extra_required_alignment var159;
struct K2_extra_size {
char a[sizeof(K2)+1];
char b;
};
struct K2_extra_size var160;
typedef union {
char c;
long long d:1 __attribute__((aligned(16)));
char e;
} L2;
L2 var161;
struct L2_extra_alignment {
char a;
L2 b;
};
struct L2_extra_alignment var162;
#pragma pack(1)
struct L2_extra_packed {
L2 a;
};
#pragma pack()
struct L2_extra_required_alignment {
char a;
struct L2_extra_packed b;
};
struct L2_extra_required_alignment var163;
struct L2_extra_size {
char a[sizeof(L2)+1];
char b;
};
struct L2_extra_size var164;
typedef union {
char c;
long long d:1 __attribute__((aligned(2))) __attribute__((packed));
char e;
} M2;
M2 var165;
struct M2_extra_alignment {
char a;
M2 b;
};
struct M2_extra_alignment var166;
#pragma pack(1)
struct M2_extra_packed {
M2 a;
};
#pragma pack()
struct M2_extra_required_alignment {
char a;
struct M2_extra_packed b;
};
struct M2_extra_required_alignment var167;
struct M2_extra_size {
char a[sizeof(M2)+1];
char b;
};
struct M2_extra_size var168;
#pragma pack(2)
typedef union {
char c;
long long d:1 __attribute__((aligned(4))) __attribute__((packed));
char e;
} N2;
N2 var169;
#pragma pack()
struct N2_extra_alignment {
char a;
N2 b;
};
struct N2_extra_alignment var170;
#pragma pack(1)
struct N2_extra_packed {
N2 a;
};
#pragma pack()
struct N2_extra_required_alignment {
char a;
struct N2_extra_packed b;
};
struct N2_extra_required_alignment var171;
struct N2_extra_size {
char a[sizeof(N2)+1];
char b;
};
struct N2_extra_size var172;
typedef union {
char c;
long long d:1 __attribute__((packed));
char e;
} O2;
O2 var173;
struct O2_extra_alignment {
char a;
O2 b;
};
struct O2_extra_alignment var174;
#pragma pack(1)
struct O2_extra_packed {
O2 a;
};
#pragma pack()
struct O2_extra_required_alignment {
char a;
struct O2_extra_packed b;
};
struct O2_extra_required_alignment var175;
struct O2_extra_size {
char a[sizeof(O2)+1];
char b;
};
struct O2_extra_size var176;
#pragma pack(2)
typedef union {
char c;
long long d:1;
char e;
} P2;
P2 var177;
#pragma pack()
struct P2_extra_alignment {
char a;
P2 b;
};
struct P2_extra_alignment var178;
#pragma pack(1)
struct P2_extra_packed {
P2 a;
};
#pragma pack()
struct P2_extra_required_alignment {
char a;
struct P2_extra_packed b;
};
struct P2_extra_required_alignment var179;
struct P2_extra_size {
char a[sizeof(P2)+1];
char b;
};
struct P2_extra_size var180;
typedef union {
char c;
char x:1;
long long d:1;
char e;
} Q2;
Q2 var181;
struct Q2_extra_alignment {
char a;
Q2 b;
};
struct Q2_extra_alignment var182;
#pragma pack(1)
struct Q2_extra_packed {
Q2 a;
};
#pragma pack()
struct Q2_extra_required_alignment {
char a;
struct Q2_extra_packed b;
};
struct Q2_extra_required_alignment var183;
struct Q2_extra_size {
char a[sizeof(Q2)+1];
char b;
};
struct Q2_extra_size var184;
typedef union {
char c;
char x:1;
long long:0 __attribute__((aligned(16)));
char e;
} R2;
R2 var185;
struct R2_extra_alignment {
char a;
R2 b;
};
struct R2_extra_alignment var186;
#pragma pack(1)
struct R2_extra_packed {
R2 a;
};
#pragma pack()
struct R2_extra_required_alignment {
char a;
struct R2_extra_packed b;
};
struct R2_extra_required_alignment var187;
struct R2_extra_size {
char a[sizeof(R2)+1];
char b;
};
struct R2_extra_size var188;
typedef union {
char c;
char x:1;
long long:0 __attribute__((aligned(2))) __attribute__((packed));
char e;
} S2;
S2 var189;
struct S2_extra_alignment {
char a;
S2 b;
};
struct S2_extra_alignment var190;
#pragma pack(1)
struct S2_extra_packed {
S2 a;
};
#pragma pack()
struct S2_extra_required_alignment {
char a;
struct S2_extra_packed b;
};
struct S2_extra_required_alignment var191;
struct S2_extra_size {
char a[sizeof(S2)+1];
char b;
};
struct S2_extra_size var192;
#pragma pack(2)
typedef union {
char c;
char x:1;
long long:0 __attribute__((aligned(4))) __attribute__((packed));
char e;
} T2;
T2 var193;
#pragma pack()
struct T2_extra_alignment {
char a;
T2 b;
};
struct T2_extra_alignment var194;
#pragma pack(1)
struct T2_extra_packed {
T2 a;
};
#pragma pack()
struct T2_extra_required_alignment {
char a;
struct T2_extra_packed b;
};
struct T2_extra_required_alignment var195;
struct T2_extra_size {
char a[sizeof(T2)+1];
char b;
};
struct T2_extra_size var196;
typedef union {
char c;
char x:1;
long long:0 __attribute__((packed));
char e;
} U2;
U2 var197;
struct U2_extra_alignment {
char a;
U2 b;
};
struct U2_extra_alignment var198;
#pragma pack(1)
struct U2_extra_packed {
U2 a;
};
#pragma pack()
struct U2_extra_required_alignment {
char a;
struct U2_extra_packed b;
};
struct U2_extra_required_alignment var199;
struct U2_extra_size {
char a[sizeof(U2)+1];
char b;
};
struct U2_extra_size var200;
#pragma pack(2)
typedef union {
char c;
char x:1;
long long:0;
char e;
} V2;
V2 var201;
#pragma pack()
struct V2_extra_alignment {
char a;
V2 b;
};
struct V2_extra_alignment var202;
#pragma pack(1)
struct V2_extra_packed {
V2 a;
};
#pragma pack()
struct V2_extra_required_alignment {
char a;
struct V2_extra_packed b;
};
struct V2_extra_required_alignment var203;
struct V2_extra_size {
char a[sizeof(V2)+1];
char b;
};
struct V2_extra_size var204;
typedef union {
char c;
char x:1;
long long:0 __attribute__((aligned(16))) __attribute__((packed));
char e;
} W2;
W2 var205;
struct W2_extra_alignment {
char a;
W2 b;
};
struct W2_extra_alignment var206;
#pragma pack(1)
struct W2_extra_packed {
W2 a;
};
#pragma pack()
struct W2_extra_required_alignment {
char a;
struct W2_extra_packed b;
};
struct W2_extra_required_alignment var207;
struct W2_extra_size {
char a[sizeof(W2)+1];
char b;
};
struct W2_extra_size var208;
#pragma pack(1)
typedef union {
char c;
long long:0 __attribute__((aligned(16)));
char e;
} W_2;
W_2 var209;
#pragma pack()
struct W_2_extra_alignment {
char a;
W_2 b;
};
struct W_2_extra_alignment var210;
#pragma pack(1)
struct W_2_extra_packed {
W_2 a;
};
#pragma pack()
struct W_2_extra_required_alignment {
char a;
struct W_2_extra_packed b;
};
struct W_2_extra_required_alignment var211;
struct W_2_extra_size {
char a[sizeof(W_2)+1];
char b;
};
struct W_2_extra_size var212;
#pragma pack(2)
typedef union {
char c;
char x:1;
long long:0 __attribute__((aligned(16))) __attribute__((packed));
char e;
} X2;
X2 var213;
#pragma pack()
struct X2_extra_alignment {
char a;
X2 b;
};
struct X2_extra_alignment var214;
#pragma pack(1)
struct X2_extra_packed {
X2 a;
};
#pragma pack()
struct X2_extra_required_alignment {
char a;
struct X2_extra_packed b;
};
struct X2_extra_required_alignment var215;
struct X2_extra_size {
char a[sizeof(X2)+1];
char b;
};
struct X2_extra_size var216;
typedef struct {
char c:1;
long long:0 __attribute__((packed));
char d;
} Y;
Y var217;
struct Y_extra_alignment {
char a;
Y b;
};
struct Y_extra_alignment var218;
#pragma pack(1)
struct Y_extra_packed {
Y a;
};
#pragma pack()
struct Y_extra_required_alignment {
char a;
struct Y_extra_packed b;
};
struct Y_extra_required_alignment var219;
struct Y_extra_size {
char a[sizeof(Y)+1];
char b;
};
struct Y_extra_size var220;
typedef union {
char c:1;
long long:0 __attribute__((packed));
char d;
} Y2;
Y2 var221;
struct Y2_extra_alignment {
char a;
Y2 b;
};
struct Y2_extra_alignment var222;
#pragma pack(1)
struct Y2_extra_packed {
Y2 a;
};
#pragma pack()
struct Y2_extra_required_alignment {
char a;
struct Y2_extra_packed b;
};
struct Y2_extra_required_alignment var223;
struct Y2_extra_size {
char a[sizeof(Y2)+1];
char b;
};
struct Y2_extra_size var224;
typedef struct {
char c:1;
long long:0 __attribute__((aligned(32)));
char d:1;
} A3;
A3 var225;
struct A3_extra_alignment {
char a;
A3 b;
};
struct A3_extra_alignment var226;
#pragma pack(1)
struct A3_extra_packed {
A3 a;
};
#pragma pack()
struct A3_extra_required_alignment {
char a;
struct A3_extra_packed b;
};
struct A3_extra_required_alignment var227;
struct A3_extra_size {
char a[sizeof(A3)+1];
char b;
};
struct A3_extra_size var228;
typedef char A4 __attribute__((aligned(32)));
A4 var229;
struct A4_extra_alignment {
char a;
A4 b;
};
struct A4_extra_alignment var230;
#pragma pack(1)
struct A4_extra_packed {
A4 a;
};
#pragma pack()
struct A4_extra_required_alignment {
char a;
struct A4_extra_packed b;
};
struct A4_extra_required_alignment var231;
struct A4_extra_size {
char a[sizeof(A4)+1];
char b;
};
struct A4_extra_size var232;
typedef struct {
char c:1;
A4:0;
char d:1;
} A5;
A5 var233;
struct A5_extra_alignment {
char a;
A5 b;
};
struct A5_extra_alignment var234;
#pragma pack(1)
struct A5_extra_packed {
A5 a;
};
#pragma pack()
struct A5_extra_required_alignment {
char a;
struct A5_extra_packed b;
};
struct A5_extra_required_alignment var235;
struct A5_extra_size {
char a[sizeof(A5)+1];
char b;
};
struct A5_extra_size var236;
typedef struct {
A4 a;
} A7;
A7 var237;
struct A7_extra_alignment {
char a;
A7 b;
};
struct A7_extra_alignment var238;
#pragma pack(1)
struct A7_extra_packed {
A7 a;
};
#pragma pack()
struct A7_extra_required_alignment {
char a;
struct A7_extra_packed b;
};
struct A7_extra_required_alignment var239;
struct A7_extra_size {
char a[sizeof(A7)+1];
char b;
};
struct A7_extra_size var240;
typedef struct {
char c;
long i:31 __attribute__((packed));
long j:2;
} A8;
A8 var241;
struct A8_extra_alignment {
char a;
A8 b;
};
struct A8_extra_alignment var242;
#pragma pack(1)
struct A8_extra_packed {
A8 a;
};
#pragma pack()
struct A8_extra_required_alignment {
char a;
struct A8_extra_packed b;
};
struct A8_extra_required_alignment var243;
struct A8_extra_size {
char a[sizeof(A8)+1];
char b;
};
struct A8_extra_size var244;
typedef struct {
char c;
long i:31 __attribute__((packed));
long j;
} A9;
A9 var245;
struct A9_extra_alignment {
char a;
A9 b;
};
struct A9_extra_alignment var246;
#pragma pack(1)
struct A9_extra_packed {
A9 a;
};
#pragma pack()
struct A9_extra_required_alignment {
char a;
struct A9_extra_packed b;
};
struct A9_extra_required_alignment var247;
struct A9_extra_size {
char a[sizeof(A9)+1];
char b;
};
struct A9_extra_size var248;
typedef long A10 __attribute__((aligned(16)));
A10 var249;
struct A10_extra_alignment {
char a;
A10 b;
};
struct A10_extra_alignment var250;
#pragma pack(1)
struct A10_extra_packed {
A10 a;
};
#pragma pack()
struct A10_extra_required_alignment {
char a;
struct A10_extra_packed b;
};
struct A10_extra_required_alignment var251;
struct A10_extra_size {
char a[sizeof(A10)+1];
char b;
};
struct A10_extra_size var252;
typedef struct {
char c;
long i:31 __attribute__((packed));
A10 j:2;
} A11;
A11 var253;
struct A11_extra_alignment {
char a;
A11 b;
};
struct A11_extra_alignment var254;
#pragma pack(1)
struct A11_extra_packed {
A11 a;
};
#pragma pack()
struct A11_extra_required_alignment {
char a;
struct A11_extra_packed b;
};
struct A11_extra_required_alignment var255;
struct A11_extra_size {
char a[sizeof(A11)+1];
char b;
};
struct A11_extra_size var256;
typedef struct {
char c;
long i:31 __attribute__((packed));
A10 j;
} A12;
A12 var257;
struct A12_extra_alignment {
char a;
A12 b;
};
struct A12_extra_alignment var258;
#pragma pack(1)
struct A12_extra_packed {
A12 a;
};
#pragma pack()
struct A12_extra_required_alignment {
char a;
struct A12_extra_packed b;
};
struct A12_extra_required_alignment var259;
struct A12_extra_size {
char a[sizeof(A12)+1];
char b;
};
struct A12_extra_size var260;
typedef struct {
char c;
long i:1;
long j:1 __attribute__((aligned(16)));
char d;
} A13;
A13 var261;
struct A13_extra_alignment {
char a;
A13 b;
};
struct A13_extra_alignment var262;
#pragma pack(1)
struct A13_extra_packed {
A13 a;
};
#pragma pack()
struct A13_extra_required_alignment {
char a;
struct A13_extra_packed b;
};
struct A13_extra_required_alignment var263;
struct A13_extra_size {
char a[sizeof(A13)+1];
char b;
};
struct A13_extra_size var264;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|powerpc64-ppc64-freebsd-gnu:Clang|riscv64-baseline_rv64-other-eabi:Clang|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|sparc64-v9-solaris-eabi:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Sparcv9SunSolaris|Some("sparc64-v9-solaris-eabi") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 5, "");
_Static_assert(_Alignof(A_) == 1, "");
_Static_assert(sizeof(struct A__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_packed) == 5, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 7, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 9, "");
_Static_assert(_Alignof(B_) == 1, "");
_Static_assert(sizeof(struct B__extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_packed) == 9, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 11, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 64, "");
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 9, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 9, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 11, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 64, "");
#endif
_Static_assert(sizeof(D) == 24, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 24, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 26, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 128, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 16, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 8, "");
_Static_assert(_Alignof(Q) == 8, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 17, "");
_Static_assert(_Alignof(R) == 1, "");
_Static_assert(sizeof(struct R_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_packed) == 17, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 19, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 9, "");
_Static_assert(_Alignof(S) == 1, "");
_Static_assert(sizeof(struct S_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_packed) == 9, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 11, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 64, "");
#endif
_Static_assert(sizeof(T) == 9, "");
_Static_assert(_Alignof(T) == 1, "");
_Static_assert(sizeof(struct T_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_packed) == 9, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 11, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 64, "");
#endif
_Static_assert(sizeof(U) == 9, "");
_Static_assert(_Alignof(U) == 1, "");
_Static_assert(sizeof(struct U_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_packed) == 9, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 11, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 64, "");
#endif
_Static_assert(sizeof(V) == 9, "");
_Static_assert(_Alignof(V) == 1, "");
_Static_assert(sizeof(struct V_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_packed) == 9, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 11, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 64, "");
#endif
_Static_assert(sizeof(W) == 17, "");
_Static_assert(_Alignof(W) == 1, "");
_Static_assert(sizeof(struct W_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_packed) == 17, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 19, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 17, "");
_Static_assert(_Alignof(W_) == 1, "");
_Static_assert(sizeof(struct W__extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_packed) == 17, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 19, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 17, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 17, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 19, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 1, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 1, "");
_Static_assert(_Alignof(A_2) == 1, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 1, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 1, "");
_Static_assert(_Alignof(B_2) == 1, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 1, "");
_Static_assert(_Alignof(C22) == 1, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 3, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 8, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 8, "");
_Static_assert(_Alignof(K2) == 8, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 10, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 8, "");
_Static_assert(_Alignof(Q2) == 8, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 1, "");
_Static_assert(_Alignof(R2) == 1, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 3, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 1, "");
_Static_assert(_Alignof(S2) == 1, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 3, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 1, "");
_Static_assert(_Alignof(T2) == 1, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 3, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 1, "");
_Static_assert(_Alignof(U2) == 1, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 3, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 1, "");
_Static_assert(_Alignof(V2) == 1, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 3, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 1, "");
_Static_assert(_Alignof(W2) == 1, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 1, "");
_Static_assert(_Alignof(W_2) == 1, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 1, "");
_Static_assert(_Alignof(X2) == 1, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 3, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 9, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 9, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 11, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 64, "");
#endif
_Static_assert(sizeof(Y2) == 1, "");
_Static_assert(_Alignof(Y2) == 1, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 33, "");
_Static_assert(_Alignof(A3) == 1, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 35, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 33, "");
_Static_assert(_Alignof(A5) == 1, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 35, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 8, "");
_Static_assert(_Alignof(A8) == 8, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A8_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 10, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 16, "");
_Static_assert(_Alignof(A9) == 8, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A9_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 18, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 8, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 10, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 16, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 18, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 39, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|TWO|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|END
// repr targets Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None
#elif defined(TWO)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 8, "");
_Static_assert(_Alignof(A_) == 4, "");
_Static_assert(sizeof(struct A__extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 4, "");
_Static_assert(sizeof(struct A__extra_packed) == 8, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 10, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 16, "");
_Static_assert(_Alignof(B_) == 8, "");
_Static_assert(sizeof(struct B__extra_alignment) == 24, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 8, "");
_Static_assert(sizeof(struct B__extra_packed) == 16, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 18, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 64, "");
#endif
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 16, "");
_Static_assert(_Alignof(C_) == 8, "");
_Static_assert(sizeof(struct C__extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 8, "");
_Static_assert(sizeof(struct C__extra_packed) == 16, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 18, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 64, "");
#endif
_Static_assert(sizeof(D) == 24, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 24, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 26, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 128, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 16, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 8, "");
_Static_assert(_Alignof(Q) == 8, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 32, "");
_Static_assert(_Alignof(R) == 16, "");
_Static_assert(sizeof(struct R_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R_extra_packed) == 32, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 34, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 16, "");
_Static_assert(_Alignof(S) == 8, "");
_Static_assert(sizeof(struct S_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 8, "");
_Static_assert(sizeof(struct S_extra_packed) == 16, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 18, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 64, "");
#endif
_Static_assert(sizeof(T) == 16, "");
_Static_assert(_Alignof(T) == 8, "");
_Static_assert(sizeof(struct T_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 8, "");
_Static_assert(sizeof(struct T_extra_packed) == 16, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 18, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 64, "");
#endif
_Static_assert(sizeof(U) == 16, "");
_Static_assert(_Alignof(U) == 8, "");
_Static_assert(sizeof(struct U_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 8, "");
_Static_assert(sizeof(struct U_extra_packed) == 16, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 18, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 64, "");
#endif
_Static_assert(sizeof(V) == 16, "");
_Static_assert(_Alignof(V) == 8, "");
_Static_assert(sizeof(struct V_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 8, "");
_Static_assert(sizeof(struct V_extra_packed) == 16, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 18, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 64, "");
#endif
_Static_assert(sizeof(W) == 32, "");
_Static_assert(_Alignof(W) == 16, "");
_Static_assert(sizeof(struct W_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_extra_packed) == 32, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 34, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 32, "");
_Static_assert(_Alignof(W_) == 16, "");
_Static_assert(sizeof(struct W__extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 16, "");
_Static_assert(sizeof(struct W__extra_packed) == 32, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 34, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 32, "");
_Static_assert(_Alignof(X) == 16, "");
_Static_assert(sizeof(struct X_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X_extra_packed) == 32, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 34, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 4, "");
_Static_assert(_Alignof(A2) == 4, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 4, "");
_Static_assert(_Alignof(A_2) == 4, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 8, "");
_Static_assert(_Alignof(B2) == 8, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 8, "");
_Static_assert(_Alignof(B_2) == 8, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 8, "");
_Static_assert(_Alignof(C2) == 8, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 10, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 8, "");
_Static_assert(_Alignof(C22) == 8, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C22_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 10, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 8, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 8, "");
_Static_assert(_Alignof(K2) == 8, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 10, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 8, "");
_Static_assert(_Alignof(Q2) == 8, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 16, "");
_Static_assert(_Alignof(R2) == 16, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 18, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 8, "");
_Static_assert(_Alignof(S2) == 8, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct S2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 10, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 8, "");
_Static_assert(_Alignof(T2) == 8, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct T2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 10, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 8, "");
_Static_assert(_Alignof(U2) == 8, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct U2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 10, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 8, "");
_Static_assert(_Alignof(V2) == 8, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct V2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 10, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 16, "");
_Static_assert(_Alignof(W2) == 16, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 16, "");
_Static_assert(_Alignof(W_2) == 16, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 16, "");
_Static_assert(_Alignof(X2) == 16, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 18, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 16, "");
_Static_assert(_Alignof(Y) == 8, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y_extra_packed) == 16, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 18, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 64, "");
#endif
_Static_assert(sizeof(Y2) == 8, "");
_Static_assert(_Alignof(Y2) == 8, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 64, "");
_Static_assert(_Alignof(A3) == 32, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A3_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 66, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 64, "");
_Static_assert(_Alignof(A5) == 32, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A5_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 66, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 8, "");
_Static_assert(_Alignof(A8) == 8, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A8_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 10, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 16, "");
_Static_assert(_Alignof(A9) == 8, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A9_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 18, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 8, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 10, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 16, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 18, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 39, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|THREE|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|END
// repr targets Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl")
#elif defined(THREE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 8, "");
_Static_assert(_Alignof(A_) == 4, "");
_Static_assert(sizeof(struct A__extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 4, "");
_Static_assert(sizeof(struct A__extra_packed) == 8, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 10, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 16, "");
_Static_assert(_Alignof(B_) == 8, "");
_Static_assert(sizeof(struct B__extra_alignment) == 24, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 8, "");
_Static_assert(sizeof(struct B__extra_packed) == 16, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 18, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 64, "");
#endif
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 16, "");
_Static_assert(_Alignof(C_) == 8, "");
_Static_assert(sizeof(struct C__extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 8, "");
_Static_assert(sizeof(struct C__extra_packed) == 16, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 18, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 64, "");
#endif
_Static_assert(sizeof(D) == 24, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 24, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 26, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 128, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 24, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 8, "");
_Static_assert(_Alignof(Q) == 8, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 32, "");
_Static_assert(_Alignof(R) == 16, "");
_Static_assert(sizeof(struct R_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R_extra_packed) == 32, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 34, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 16, "");
_Static_assert(_Alignof(S) == 8, "");
_Static_assert(sizeof(struct S_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 8, "");
_Static_assert(sizeof(struct S_extra_packed) == 16, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 18, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 64, "");
#endif
_Static_assert(sizeof(T) == 16, "");
_Static_assert(_Alignof(T) == 8, "");
_Static_assert(sizeof(struct T_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 8, "");
_Static_assert(sizeof(struct T_extra_packed) == 16, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 18, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 64, "");
#endif
_Static_assert(sizeof(U) == 16, "");
_Static_assert(_Alignof(U) == 8, "");
_Static_assert(sizeof(struct U_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 8, "");
_Static_assert(sizeof(struct U_extra_packed) == 16, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 18, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 64, "");
#endif
_Static_assert(sizeof(V) == 16, "");
_Static_assert(_Alignof(V) == 8, "");
_Static_assert(sizeof(struct V_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 8, "");
_Static_assert(sizeof(struct V_extra_packed) == 16, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 18, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 64, "");
#endif
_Static_assert(sizeof(W) == 32, "");
_Static_assert(_Alignof(W) == 16, "");
_Static_assert(sizeof(struct W_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_extra_packed) == 32, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 34, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 32, "");
_Static_assert(_Alignof(W_) == 16, "");
_Static_assert(sizeof(struct W__extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 16, "");
_Static_assert(sizeof(struct W__extra_packed) == 32, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 34, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 32, "");
_Static_assert(_Alignof(X) == 16, "");
_Static_assert(sizeof(struct X_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X_extra_packed) == 32, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 34, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 4, "");
_Static_assert(_Alignof(A2) == 4, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 4, "");
_Static_assert(_Alignof(A_2) == 4, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 8, "");
_Static_assert(_Alignof(B2) == 8, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 8, "");
_Static_assert(_Alignof(B_2) == 8, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 8, "");
_Static_assert(_Alignof(C2) == 8, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 10, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 8, "");
_Static_assert(_Alignof(C22) == 8, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C22_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 10, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 8, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 8, "");
_Static_assert(_Alignof(K2) == 8, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 10, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 8, "");
_Static_assert(_Alignof(Q2) == 8, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 16, "");
_Static_assert(_Alignof(R2) == 16, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 18, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 8, "");
_Static_assert(_Alignof(S2) == 8, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct S2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 10, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 8, "");
_Static_assert(_Alignof(T2) == 8, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct T2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 10, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 8, "");
_Static_assert(_Alignof(U2) == 8, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct U2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 10, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 8, "");
_Static_assert(_Alignof(V2) == 8, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct V2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 10, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 16, "");
_Static_assert(_Alignof(W2) == 16, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 16, "");
_Static_assert(_Alignof(W_2) == 16, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 16, "");
_Static_assert(_Alignof(X2) == 16, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 18, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 16, "");
_Static_assert(_Alignof(Y) == 8, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y_extra_packed) == 16, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 18, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 64, "");
#endif
_Static_assert(sizeof(Y2) == 8, "");
_Static_assert(_Alignof(Y2) == 8, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 64, "");
_Static_assert(_Alignof(A3) == 32, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A3_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 66, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 64, "");
_Static_assert(_Alignof(A5) == 32, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A5_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 66, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 8, "");
_Static_assert(_Alignof(A8) == 8, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A8_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 10, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 16, "");
_Static_assert(_Alignof(A9) == 8, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A9_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 18, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 8, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 10, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 32, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 34, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 128, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|FOUR|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-arm1136j_s-freebsd-gnueabihf:Clang|arm-arm1136j_s-netbsd-eabihf:Clang|arm-baseline-other-eabi:Clang|arm-baseline-other-eabihf:Clang|arm-cortex_r4-linux-android:Clang|arm-cortex_r4-other-eabi:Clang|arm-cortex_r4-other-eabihf:Clang|arm-cortex_r4-freebsd-gnueabihf:Clang|arm-cortex_r4-netbsd-eabihf:Clang|thumb-arm710t-other-eabi:Clang|thumb-cortex_m0-other-eabi:Clang|thumb-cortex_m4-other-eabihf:Clang|thumb-cortex_m4-other-eabi:Clang|thumb-cortex_m3-other-eabi:Clang|thumb-baseline-other-eabi:Clang|thumb-cortex_m33-other-eabihf:Clang|thumb-cortex_m33-other-eabi:Clang|END
// repr targets Armebv7rUnknownNoneEabi|Some("arm-baseline-other-eabi") Armebv7rUnknownNoneEabihf|Some("arm-baseline-other-eabihf") ArmLinuxAndroideabi|None Armv6UnknownFreebsdGnueabihf|Some("arm-arm1136j_s-freebsd-gnueabihf") Armv6UnknownNetbsdelfEabihf|Some("arm-arm1136j_s-netbsd-eabihf") Armv7aNoneEabi|Some("arm-baseline-other-eabi") Armv7aNoneEabihf|Some("arm-baseline-other-eabihf") Armv7NoneLinuxAndroid|Some("arm-cortex_r4-linux-android") Armv7rUnknownNoneEabi|Some("arm-cortex_r4-other-eabi") Armv7rUnknownNoneEabihf|Some("arm-cortex_r4-other-eabihf") Armv7UnknownFreebsdGnueabihf|Some("arm-cortex_r4-freebsd-gnueabihf") Armv7UnknownNetbsdelfEabihf|Some("arm-cortex_r4-netbsd-eabihf") Thumbv4tNoneEabi|Some("thumb-arm710t-other-eabi") Thumbv6mNoneEabi|Some("thumb-cortex_m0-other-eabi") Thumbv7emNoneEabihf|Some("thumb-cortex_m4-other-eabihf") Thumbv7emNoneEabi|Some("thumb-cortex_m4-other-eabi") Thumbv7mNoneEabi|Some("thumb-cortex_m3-other-eabi") Thumbv8mBaseNoneEabi|Some("thumb-baseline-other-eabi") Thumbv8mMainNoneEabihf|Some("thumb-cortex_m33-other-eabihf") Thumbv8mMainNoneEabi|Some("thumb-cortex_m33-other-eabi")
#elif defined(FOUR)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 8, "");
_Static_assert(_Alignof(A_) == 4, "");
_Static_assert(sizeof(struct A__extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 4, "");
_Static_assert(sizeof(struct A__extra_packed) == 8, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 10, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 16, "");
_Static_assert(_Alignof(B_) == 8, "");
_Static_assert(sizeof(struct B__extra_alignment) == 24, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 8, "");
_Static_assert(sizeof(struct B__extra_packed) == 16, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 18, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 64, "");
#endif
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 16, "");
_Static_assert(_Alignof(C_) == 8, "");
_Static_assert(sizeof(struct C__extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 8, "");
_Static_assert(sizeof(struct C__extra_packed) == 16, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 18, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 64, "");
#endif
_Static_assert(sizeof(D) == 24, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 24, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 26, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 128, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 16, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 8, "");
_Static_assert(_Alignof(Q) == 8, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 32, "");
_Static_assert(_Alignof(R) == 16, "");
_Static_assert(sizeof(struct R_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R_extra_packed) == 32, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 34, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 16, "");
_Static_assert(_Alignof(S) == 8, "");
_Static_assert(sizeof(struct S_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 8, "");
_Static_assert(sizeof(struct S_extra_packed) == 16, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 18, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 64, "");
#endif
_Static_assert(sizeof(T) == 16, "");
_Static_assert(_Alignof(T) == 8, "");
_Static_assert(sizeof(struct T_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 8, "");
_Static_assert(sizeof(struct T_extra_packed) == 16, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 18, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 64, "");
#endif
_Static_assert(sizeof(U) == 16, "");
_Static_assert(_Alignof(U) == 8, "");
_Static_assert(sizeof(struct U_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 8, "");
_Static_assert(sizeof(struct U_extra_packed) == 16, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 18, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 64, "");
#endif
_Static_assert(sizeof(V) == 16, "");
_Static_assert(_Alignof(V) == 8, "");
_Static_assert(sizeof(struct V_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 8, "");
_Static_assert(sizeof(struct V_extra_packed) == 16, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 18, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 64, "");
#endif
_Static_assert(sizeof(W) == 32, "");
_Static_assert(_Alignof(W) == 16, "");
_Static_assert(sizeof(struct W_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_extra_packed) == 32, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 34, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 32, "");
_Static_assert(_Alignof(W_) == 16, "");
_Static_assert(sizeof(struct W__extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 16, "");
_Static_assert(sizeof(struct W__extra_packed) == 32, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 34, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 32, "");
_Static_assert(_Alignof(X) == 16, "");
_Static_assert(sizeof(struct X_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X_extra_packed) == 32, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 34, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 4, "");
_Static_assert(_Alignof(A2) == 4, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 4, "");
_Static_assert(_Alignof(A_2) == 4, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 8, "");
_Static_assert(_Alignof(B2) == 8, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 8, "");
_Static_assert(_Alignof(B_2) == 8, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 8, "");
_Static_assert(_Alignof(C2) == 8, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 10, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 8, "");
_Static_assert(_Alignof(C22) == 8, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C22_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 10, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 8, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 8, "");
_Static_assert(_Alignof(K2) == 8, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 10, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 8, "");
_Static_assert(_Alignof(Q2) == 8, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 16, "");
_Static_assert(_Alignof(R2) == 16, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 18, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 8, "");
_Static_assert(_Alignof(S2) == 8, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct S2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 10, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 8, "");
_Static_assert(_Alignof(T2) == 8, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct T2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 10, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 8, "");
_Static_assert(_Alignof(U2) == 8, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct U2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 10, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 8, "");
_Static_assert(_Alignof(V2) == 8, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct V2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 10, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 16, "");
_Static_assert(_Alignof(W2) == 16, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 16, "");
_Static_assert(_Alignof(W_2) == 16, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 16, "");
_Static_assert(_Alignof(X2) == 16, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 18, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 16, "");
_Static_assert(_Alignof(Y) == 8, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y_extra_packed) == 16, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 18, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 64, "");
#endif
_Static_assert(sizeof(Y2) == 8, "");
_Static_assert(_Alignof(Y2) == 8, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 64, "");
_Static_assert(_Alignof(A3) == 32, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A3_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 66, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 64, "");
_Static_assert(_Alignof(A5) == 32, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A5_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 66, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 8, "");
_Static_assert(_Alignof(A8) == 4, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A8_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 10, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 12, "");
_Static_assert(_Alignof(A9) == 4, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A9_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 14, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 4, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 6, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 32, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 34, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 128, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|FIVE|arm-baseline-linux-gnueabi:Gcc|arm-baseline-linux-gnueabihf:Gcc|arm-arm710t-linux-gnueabi:Gcc|arm-arm1020e-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabi:Gcc|arm-cortex_r4-linux-gnueabihf:Gcc|END
// repr targets ArmUnknownLinuxGnueabi|Some("arm-baseline-linux-gnueabi") ArmUnknownLinuxGnueabihf|Some("arm-baseline-linux-gnueabihf") Armv4tUnknownLinuxGnueabi|Some("arm-arm710t-linux-gnueabi") Armv5teUnknownLinuxGnueabi|Some("arm-arm1020e-linux-gnueabi") Armv5teUnknownLinuxUclibcgnueabi|None Armv7UnknownLinuxGnueabi|Some("arm-cortex_r4-linux-gnueabi") Armv7UnknownLinuxGnueabihf|Some("arm-cortex_r4-linux-gnueabihf")
#elif defined(FIVE)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 8, "");
_Static_assert(_Alignof(A_) == 4, "");
_Static_assert(sizeof(struct A__extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 4, "");
_Static_assert(sizeof(struct A__extra_packed) == 8, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 10, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 8, "");
_Static_assert(_Alignof(B) == 8, "");
_Static_assert(sizeof(struct B_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 16, "");
_Static_assert(_Alignof(B_) == 8, "");
_Static_assert(sizeof(struct B__extra_alignment) == 24, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 8, "");
_Static_assert(sizeof(struct B__extra_packed) == 16, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 18, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 64, "");
#endif
_Static_assert(sizeof(C) == 8, "");
_Static_assert(_Alignof(C) == 8, "");
_Static_assert(sizeof(struct C_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 10, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 16, "");
_Static_assert(_Alignof(C_) == 8, "");
_Static_assert(sizeof(struct C__extra_alignment) == 24, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 8, "");
_Static_assert(sizeof(struct C__extra_packed) == 16, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 18, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 64, "");
#endif
_Static_assert(sizeof(D) == 24, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 24, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 26, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 128, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 24, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 8, "");
_Static_assert(_Alignof(Q) == 8, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 32, "");
_Static_assert(_Alignof(R) == 16, "");
_Static_assert(sizeof(struct R_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R_extra_packed) == 32, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 34, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 16, "");
_Static_assert(_Alignof(S) == 8, "");
_Static_assert(sizeof(struct S_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 8, "");
_Static_assert(sizeof(struct S_extra_packed) == 16, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 18, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 64, "");
#endif
_Static_assert(sizeof(T) == 16, "");
_Static_assert(_Alignof(T) == 8, "");
_Static_assert(sizeof(struct T_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 8, "");
_Static_assert(sizeof(struct T_extra_packed) == 16, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 18, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 64, "");
#endif
_Static_assert(sizeof(U) == 16, "");
_Static_assert(_Alignof(U) == 8, "");
_Static_assert(sizeof(struct U_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 8, "");
_Static_assert(sizeof(struct U_extra_packed) == 16, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 18, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 64, "");
#endif
_Static_assert(sizeof(V) == 16, "");
_Static_assert(_Alignof(V) == 8, "");
_Static_assert(sizeof(struct V_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 8, "");
_Static_assert(sizeof(struct V_extra_packed) == 16, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 18, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 64, "");
#endif
_Static_assert(sizeof(W) == 32, "");
_Static_assert(_Alignof(W) == 16, "");
_Static_assert(sizeof(struct W_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_extra_packed) == 32, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 34, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 32, "");
_Static_assert(_Alignof(W_) == 16, "");
_Static_assert(sizeof(struct W__extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 16, "");
_Static_assert(sizeof(struct W__extra_packed) == 32, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 34, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 32, "");
_Static_assert(_Alignof(X) == 16, "");
_Static_assert(sizeof(struct X_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X_extra_packed) == 32, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 34, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 4, "");
_Static_assert(_Alignof(A2) == 4, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 4, "");
_Static_assert(_Alignof(A_2) == 4, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 8, "");
_Static_assert(_Alignof(B2) == 8, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 8, "");
_Static_assert(_Alignof(B_2) == 8, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 10, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 8, "");
_Static_assert(_Alignof(C2) == 8, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 10, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 8, "");
_Static_assert(_Alignof(C22) == 8, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 8, "");
_Static_assert(sizeof(struct C22_extra_packed) == 8, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 10, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 8, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 8, "");
_Static_assert(_Alignof(K2) == 8, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 10, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 8, "");
_Static_assert(_Alignof(Q2) == 8, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 16, "");
_Static_assert(_Alignof(R2) == 16, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 18, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 8, "");
_Static_assert(_Alignof(S2) == 8, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct S2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 10, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 8, "");
_Static_assert(_Alignof(T2) == 8, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct T2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 10, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 8, "");
_Static_assert(_Alignof(U2) == 8, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct U2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 10, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 8, "");
_Static_assert(_Alignof(V2) == 8, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct V2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 10, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 16, "");
_Static_assert(_Alignof(W2) == 16, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 16, "");
_Static_assert(_Alignof(W_2) == 16, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 16, "");
_Static_assert(_Alignof(X2) == 16, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 18, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 16, "");
_Static_assert(_Alignof(Y) == 8, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y_extra_packed) == 16, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 18, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 64, "");
#endif
_Static_assert(sizeof(Y2) == 8, "");
_Static_assert(_Alignof(Y2) == 8, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 64, "");
_Static_assert(_Alignof(A3) == 32, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A3_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 66, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 64, "");
_Static_assert(_Alignof(A5) == 32, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A5_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 66, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 8, "");
_Static_assert(_Alignof(A8) == 4, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A8_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 10, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 12, "");
_Static_assert(_Alignof(A9) == 4, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A9_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 14, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 4, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 6, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 32, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 34, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 128, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|SIX|arm-cortex_r4-ios-none:Clang|arm-baseline-ios-none:Clang|END
// repr targets Armv7AppleIos|Some("arm-cortex_r4-ios-none") Armv7sAppleIos|Some("arm-baseline-ios-none")
#elif defined(SIX)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 8, "");
_Static_assert(_Alignof(A_) == 4, "");
_Static_assert(sizeof(struct A__extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 4, "");
_Static_assert(sizeof(struct A__extra_packed) == 8, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 10, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 8, "");
_Static_assert(_Alignof(B_) == 4, "");
_Static_assert(sizeof(struct B__extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 4, "");
_Static_assert(sizeof(struct B__extra_packed) == 8, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 10, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 32, "");
#endif
_Static_assert(sizeof(C) == 4, "");
_Static_assert(_Alignof(C) == 4, "");
_Static_assert(sizeof(struct C_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 6, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 8, "");
_Static_assert(_Alignof(C_) == 4, "");
_Static_assert(sizeof(struct C__extra_alignment) == 12, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 4, "");
_Static_assert(sizeof(struct C__extra_packed) == 8, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 10, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 32, "");
#endif
_Static_assert(sizeof(D) == 16, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 20, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 18, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 96, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 3, "");
_Static_assert(_Alignof(K) == 1, "");
_Static_assert(sizeof(struct K_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_packed) == 3, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 5, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 16, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 3, "");
_Static_assert(_Alignof(P) == 1, "");
_Static_assert(sizeof(struct P_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_packed) == 3, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 5, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 3, "");
_Static_assert(_Alignof(Q) == 1, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_packed) == 3, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 5, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 32, "");
_Static_assert(_Alignof(R) == 16, "");
_Static_assert(sizeof(struct R_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R_extra_packed) == 32, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 34, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 8, "");
_Static_assert(_Alignof(S) == 4, "");
_Static_assert(sizeof(struct S_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 4, "");
_Static_assert(sizeof(struct S_extra_packed) == 8, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 10, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 32, "");
#endif
_Static_assert(sizeof(T) == 8, "");
_Static_assert(_Alignof(T) == 4, "");
_Static_assert(sizeof(struct T_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 4, "");
_Static_assert(sizeof(struct T_extra_packed) == 8, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 10, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 32, "");
#endif
_Static_assert(sizeof(U) == 8, "");
_Static_assert(_Alignof(U) == 4, "");
_Static_assert(sizeof(struct U_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 4, "");
_Static_assert(sizeof(struct U_extra_packed) == 8, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 10, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 32, "");
#endif
_Static_assert(sizeof(V) == 8, "");
_Static_assert(_Alignof(V) == 4, "");
_Static_assert(sizeof(struct V_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 4, "");
_Static_assert(sizeof(struct V_extra_packed) == 8, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 10, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 32, "");
#endif
_Static_assert(sizeof(W) == 32, "");
_Static_assert(_Alignof(W) == 16, "");
_Static_assert(sizeof(struct W_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_extra_packed) == 32, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 34, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 32, "");
_Static_assert(_Alignof(W_) == 16, "");
_Static_assert(sizeof(struct W__extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 16, "");
_Static_assert(sizeof(struct W__extra_packed) == 32, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 34, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 32, "");
_Static_assert(_Alignof(X) == 16, "");
_Static_assert(sizeof(struct X_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X_extra_packed) == 32, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 34, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 4, "");
_Static_assert(_Alignof(A2) == 4, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 4, "");
_Static_assert(_Alignof(A_2) == 4, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 4, "");
_Static_assert(_Alignof(B2) == 4, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 6, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 4, "");
_Static_assert(_Alignof(B_2) == 4, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 4, "");
_Static_assert(_Alignof(C2) == 4, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 6, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 4, "");
_Static_assert(_Alignof(C22) == 4, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 4, "");
_Static_assert(sizeof(struct C22_extra_packed) == 4, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 6, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 4, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 1, "");
_Static_assert(_Alignof(K2) == 1, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 3, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 1, "");
_Static_assert(_Alignof(P2) == 1, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 3, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 1, "");
_Static_assert(_Alignof(Q2) == 1, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 16, "");
_Static_assert(_Alignof(R2) == 16, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 18, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 4, "");
_Static_assert(_Alignof(S2) == 4, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct S2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 6, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 4, "");
_Static_assert(_Alignof(T2) == 4, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct T2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 6, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 4, "");
_Static_assert(_Alignof(U2) == 4, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct U2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 6, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 4, "");
_Static_assert(_Alignof(V2) == 4, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct V2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 6, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 16, "");
_Static_assert(_Alignof(W2) == 16, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 16, "");
_Static_assert(_Alignof(W_2) == 16, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 16, "");
_Static_assert(_Alignof(X2) == 16, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 18, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 8, "");
_Static_assert(_Alignof(Y) == 4, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Y_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 32, "");
#endif
_Static_assert(sizeof(Y2) == 4, "");
_Static_assert(_Alignof(Y2) == 4, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 6, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 64, "");
_Static_assert(_Alignof(A3) == 32, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A3_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 66, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 64, "");
_Static_assert(_Alignof(A5) == 32, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A5_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 66, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 6, "");
_Static_assert(_Alignof(A8) == 1, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 8, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 12, "");
_Static_assert(_Alignof(A9) == 4, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A9_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 14, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 4, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 6, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 6, "");
_Static_assert(_Alignof(A11) == 1, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 8, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 39, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|SEVEN|avr-avr2-other-eabi:Gcc|END
// repr targets AvrUnknownUnknown|Some("avr-avr2-other-eabi")
#elif defined(SEVEN)
_Static_assert(sizeof(A) == 4, "");
_Static_assert(_Alignof(A) == 4, "");
_Static_assert(sizeof(struct A_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 8, "");
_Static_assert(_Alignof(A_) == 4, "");
_Static_assert(sizeof(struct A__extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 4, "");
_Static_assert(sizeof(struct A__extra_packed) == 8, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 10, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 4, "");
_Static_assert(_Alignof(B) == 4, "");
_Static_assert(sizeof(struct B_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 8, "");
_Static_assert(_Alignof(B_) == 4, "");
_Static_assert(sizeof(struct B__extra_alignment) == 12, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 4, "");
_Static_assert(sizeof(struct B__extra_packed) == 8, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 10, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 32, "");
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 2, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 2, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 4, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 8, "");
#endif
_Static_assert(sizeof(D) == 10, "");
_Static_assert(_Alignof(D) == 1, "");
_Static_assert(sizeof(struct D_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_packed) == 10, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 12, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 72, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 10, "");
_Static_assert(_Alignof(J) == 1, "");
_Static_assert(sizeof(struct J_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_packed) == 10, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 12, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 72, "");
#endif
_Static_assert(sizeof(K) == 3, "");
_Static_assert(_Alignof(K) == 1, "");
_Static_assert(sizeof(struct K_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_packed) == 3, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 5, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 24, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 3, "");
_Static_assert(_Alignof(P) == 1, "");
_Static_assert(sizeof(struct P_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_packed) == 3, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 5, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 3, "");
_Static_assert(_Alignof(Q) == 1, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_packed) == 3, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 5, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 32, "");
_Static_assert(_Alignof(R) == 16, "");
_Static_assert(sizeof(struct R_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R_extra_packed) == 32, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 34, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 4, "");
_Static_assert(_Alignof(S) == 2, "");
_Static_assert(sizeof(struct S_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 2, "");
_Static_assert(sizeof(struct S_extra_packed) == 4, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 6, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 16, "");
#endif
_Static_assert(sizeof(T) == 8, "");
_Static_assert(_Alignof(T) == 4, "");
_Static_assert(sizeof(struct T_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 4, "");
_Static_assert(sizeof(struct T_extra_packed) == 8, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 10, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 32, "");
#endif
_Static_assert(sizeof(U) == 3, "");
_Static_assert(_Alignof(U) == 1, "");
_Static_assert(sizeof(struct U_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_packed) == 3, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 5, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 16, "");
#endif
_Static_assert(sizeof(V) == 3, "");
_Static_assert(_Alignof(V) == 1, "");
_Static_assert(sizeof(struct V_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_packed) == 3, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 5, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 16, "");
#endif
_Static_assert(sizeof(W) == 32, "");
_Static_assert(_Alignof(W) == 16, "");
_Static_assert(sizeof(struct W_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_extra_packed) == 32, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 34, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 32, "");
_Static_assert(_Alignof(W_) == 16, "");
_Static_assert(sizeof(struct W__extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 16, "");
_Static_assert(sizeof(struct W__extra_packed) == 32, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 34, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 32, "");
_Static_assert(_Alignof(X) == 16, "");
_Static_assert(sizeof(struct X_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X_extra_packed) == 32, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 34, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 4, "");
_Static_assert(_Alignof(A2) == 4, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 4, "");
_Static_assert(_Alignof(A_2) == 4, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 6, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 4, "");
_Static_assert(_Alignof(B2) == 4, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 6, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 4, "");
_Static_assert(_Alignof(B_2) == 4, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 6, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 1, "");
_Static_assert(_Alignof(C22) == 1, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 3, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 1, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 1, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 1, "");
_Static_assert(_Alignof(K2) == 1, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 3, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 1, "");
_Static_assert(_Alignof(P2) == 1, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 3, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 1, "");
_Static_assert(_Alignof(Q2) == 1, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 16, "");
_Static_assert(_Alignof(R2) == 16, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 18, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 2, "");
_Static_assert(_Alignof(S2) == 2, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct S2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 4, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 4, "");
_Static_assert(_Alignof(T2) == 4, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct T2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 6, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 1, "");
_Static_assert(_Alignof(U2) == 1, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 3, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 1, "");
_Static_assert(_Alignof(V2) == 1, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 3, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 16, "");
_Static_assert(_Alignof(W2) == 16, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 16, "");
_Static_assert(_Alignof(W_2) == 16, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 18, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 16, "");
_Static_assert(_Alignof(X2) == 16, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 18, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 2, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 4, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 8, "");
#endif
_Static_assert(sizeof(Y2) == 1, "");
_Static_assert(_Alignof(Y2) == 1, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 64, "");
_Static_assert(_Alignof(A3) == 32, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A3_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 66, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 2, "");
_Static_assert(_Alignof(A5) == 1, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 3, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_packed) == 2, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 4, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 8, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 6, "");
_Static_assert(_Alignof(A8) == 1, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 8, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 9, "");
_Static_assert(_Alignof(A9) == 1, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_packed) == 9, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 11, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 40, "");
#endif
_Static_assert(sizeof(A10) == 4, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 6, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 6, "");
_Static_assert(_Alignof(A11) == 1, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 7, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 8, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 39, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|EIGHT|hexagon-generic-linux-musl:Clang|mipsel-mips32-other-none:Clang|powerpc-ppc-netbsd-gnu:Clang|riscv32-baseline_rv32-other-eabi:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|END
// repr targets HexagonUnknownLinuxMusl|Some("hexagon-generic-linux-musl") MipselSonyPsp|None MipselUnknownNone|Some("mipsel-mips32-other-none") PowerpcUnknownLinuxGnuspe|None PowerpcUnknownNetbsd|Some("powerpc-ppc-netbsd-gnu") Riscv32|Some("riscv32-baseline_rv32-other-eabi") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl")
#elif defined(EIGHT)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 5, "");
_Static_assert(_Alignof(A_) == 1, "");
_Static_assert(sizeof(struct A__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_packed) == 5, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 7, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 9, "");
_Static_assert(_Alignof(B_) == 1, "");
_Static_assert(sizeof(struct B__extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_packed) == 9, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 11, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 64, "");
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 9, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 9, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 11, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 64, "");
#endif
_Static_assert(sizeof(D) == 24, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 24, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 26, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 128, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 16, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 8, "");
_Static_assert(_Alignof(Q) == 8, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 17, "");
_Static_assert(_Alignof(R) == 1, "");
_Static_assert(sizeof(struct R_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_packed) == 17, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 19, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 9, "");
_Static_assert(_Alignof(S) == 1, "");
_Static_assert(sizeof(struct S_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_packed) == 9, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 11, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 64, "");
#endif
_Static_assert(sizeof(T) == 9, "");
_Static_assert(_Alignof(T) == 1, "");
_Static_assert(sizeof(struct T_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_packed) == 9, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 11, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 64, "");
#endif
_Static_assert(sizeof(U) == 9, "");
_Static_assert(_Alignof(U) == 1, "");
_Static_assert(sizeof(struct U_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_packed) == 9, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 11, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 64, "");
#endif
_Static_assert(sizeof(V) == 9, "");
_Static_assert(_Alignof(V) == 1, "");
_Static_assert(sizeof(struct V_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_packed) == 9, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 11, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 64, "");
#endif
_Static_assert(sizeof(W) == 17, "");
_Static_assert(_Alignof(W) == 1, "");
_Static_assert(sizeof(struct W_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_packed) == 17, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 19, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 17, "");
_Static_assert(_Alignof(W_) == 1, "");
_Static_assert(sizeof(struct W__extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_packed) == 17, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 19, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 17, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 17, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 19, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 1, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 1, "");
_Static_assert(_Alignof(A_2) == 1, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 1, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 1, "");
_Static_assert(_Alignof(B_2) == 1, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 1, "");
_Static_assert(_Alignof(C22) == 1, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 3, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 8, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 8, "");
_Static_assert(_Alignof(K2) == 8, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 10, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 8, "");
_Static_assert(_Alignof(Q2) == 8, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 1, "");
_Static_assert(_Alignof(R2) == 1, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 3, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 1, "");
_Static_assert(_Alignof(S2) == 1, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 3, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 1, "");
_Static_assert(_Alignof(T2) == 1, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 3, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 1, "");
_Static_assert(_Alignof(U2) == 1, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 3, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 1, "");
_Static_assert(_Alignof(V2) == 1, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 3, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 1, "");
_Static_assert(_Alignof(W2) == 1, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 1, "");
_Static_assert(_Alignof(W_2) == 1, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 1, "");
_Static_assert(_Alignof(X2) == 1, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 3, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 9, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 9, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 11, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 64, "");
#endif
_Static_assert(sizeof(Y2) == 1, "");
_Static_assert(_Alignof(Y2) == 1, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 33, "");
_Static_assert(_Alignof(A3) == 1, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 35, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 33, "");
_Static_assert(_Alignof(A5) == 1, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 35, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 8, "");
_Static_assert(_Alignof(A8) == 4, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A8_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 10, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 12, "");
_Static_assert(_Alignof(A9) == 4, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A9_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 14, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 4, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 6, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 32, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 34, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 128, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|NINE|x86-pentium4-ios-none:Clang|x86-i686-macos-none:Clang|x86-i686-linux-android:Clang|x86-i686-freebsd-gnu:Clang|x86-i686-haiku-gnu:Clang|x86-i686-netbsd-gnu:Clang|x86-i686-openbsd-gnu:Clang|END
// repr targets I386AppleIos|Some("x86-pentium4-ios-none") I686AppleMacosx|Some("x86-i686-macos-none") I686LinuxAndroid|Some("x86-i686-linux-android") I686UnknownFreebsd|Some("x86-i686-freebsd-gnu") I686UnknownHaiku|Some("x86-i686-haiku-gnu") I686UnknownNetbsdelf|Some("x86-i686-netbsd-gnu") I686UnknownOpenbsd|Some("x86-i686-openbsd-gnu")
#elif defined(NINE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 5, "");
_Static_assert(_Alignof(A_) == 1, "");
_Static_assert(sizeof(struct A__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_packed) == 5, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 7, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 5, "");
_Static_assert(_Alignof(B_) == 1, "");
_Static_assert(sizeof(struct B__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_packed) == 5, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 7, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 32, "");
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 5, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 5, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 7, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 32, "");
#endif
_Static_assert(sizeof(D) == 16, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 20, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 18, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 96, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 4, "");
_Static_assert(_Alignof(K) == 4, "");
_Static_assert(sizeof(struct K_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 4, "");
_Static_assert(sizeof(struct K_extra_packed) == 4, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 6, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 16, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 4, "");
_Static_assert(_Alignof(Q) == 4, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Q_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 6, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 17, "");
_Static_assert(_Alignof(R) == 1, "");
_Static_assert(sizeof(struct R_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_packed) == 17, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 19, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 5, "");
_Static_assert(_Alignof(S) == 1, "");
_Static_assert(sizeof(struct S_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_packed) == 5, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 7, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 32, "");
#endif
_Static_assert(sizeof(T) == 5, "");
_Static_assert(_Alignof(T) == 1, "");
_Static_assert(sizeof(struct T_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_packed) == 5, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 7, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 32, "");
#endif
_Static_assert(sizeof(U) == 5, "");
_Static_assert(_Alignof(U) == 1, "");
_Static_assert(sizeof(struct U_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_packed) == 5, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 7, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 32, "");
#endif
_Static_assert(sizeof(V) == 5, "");
_Static_assert(_Alignof(V) == 1, "");
_Static_assert(sizeof(struct V_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_packed) == 5, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 7, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 32, "");
#endif
_Static_assert(sizeof(W) == 17, "");
_Static_assert(_Alignof(W) == 1, "");
_Static_assert(sizeof(struct W_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_packed) == 17, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 19, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 17, "");
_Static_assert(_Alignof(W_) == 1, "");
_Static_assert(sizeof(struct W__extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_packed) == 17, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 19, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 17, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 17, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 19, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 1, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 1, "");
_Static_assert(_Alignof(A_2) == 1, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 1, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 1, "");
_Static_assert(_Alignof(B_2) == 1, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 1, "");
_Static_assert(_Alignof(C22) == 1, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 3, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 4, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 4, "");
_Static_assert(_Alignof(K2) == 4, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct K2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 6, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 4, "");
_Static_assert(_Alignof(Q2) == 4, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 6, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 1, "");
_Static_assert(_Alignof(R2) == 1, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 3, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 1, "");
_Static_assert(_Alignof(S2) == 1, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 3, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 1, "");
_Static_assert(_Alignof(T2) == 1, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 3, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 1, "");
_Static_assert(_Alignof(U2) == 1, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 3, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 1, "");
_Static_assert(_Alignof(V2) == 1, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 3, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 1, "");
_Static_assert(_Alignof(W2) == 1, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 1, "");
_Static_assert(_Alignof(W_2) == 1, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 1, "");
_Static_assert(_Alignof(X2) == 1, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 3, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 5, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 5, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 7, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 32, "");
#endif
_Static_assert(sizeof(Y2) == 1, "");
_Static_assert(_Alignof(Y2) == 1, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 33, "");
_Static_assert(_Alignof(A3) == 1, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 35, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 33, "");
_Static_assert(_Alignof(A5) == 1, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 35, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 8, "");
_Static_assert(_Alignof(A8) == 4, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A8_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 10, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 12, "");
_Static_assert(_Alignof(A9) == 4, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A9_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 14, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 4, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 6, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 32, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 34, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 128, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|TEN|x86-i586-linux-gnu:Gcc|x86-i586-linux-musl:Gcc|x86-i686-linux-gnu:Gcc|x86-i686-linux-musl:Gcc|END
// repr targets I586UnknownLinuxGnu|Some("x86-i586-linux-gnu") I586UnknownLinuxMusl|Some("x86-i586-linux-musl") I686UnknownLinuxGnu|Some("x86-i686-linux-gnu") I686UnknownLinuxMusl|Some("x86-i686-linux-musl")
#elif defined(TEN)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 5, "");
_Static_assert(_Alignof(A_) == 1, "");
_Static_assert(sizeof(struct A__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_packed) == 5, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 7, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 5, "");
_Static_assert(_Alignof(B_) == 1, "");
_Static_assert(sizeof(struct B__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_packed) == 5, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 7, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 32, "");
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 5, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 5, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 7, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 32, "");
#endif
_Static_assert(sizeof(D) == 16, "");
_Static_assert(_Alignof(D) == 4, "");
_Static_assert(sizeof(struct D_extra_alignment) == 20, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D_extra_packed) == 16, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 18, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 32, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 96, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 4, "");
_Static_assert(_Alignof(K) == 4, "");
_Static_assert(sizeof(struct K_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 4, "");
_Static_assert(sizeof(struct K_extra_packed) == 4, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 6, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 24, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 4, "");
_Static_assert(_Alignof(Q) == 4, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Q_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 6, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 17, "");
_Static_assert(_Alignof(R) == 1, "");
_Static_assert(sizeof(struct R_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_packed) == 17, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 19, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 5, "");
_Static_assert(_Alignof(S) == 1, "");
_Static_assert(sizeof(struct S_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_packed) == 5, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 7, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 32, "");
#endif
_Static_assert(sizeof(T) == 5, "");
_Static_assert(_Alignof(T) == 1, "");
_Static_assert(sizeof(struct T_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_packed) == 5, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 7, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 32, "");
#endif
_Static_assert(sizeof(U) == 5, "");
_Static_assert(_Alignof(U) == 1, "");
_Static_assert(sizeof(struct U_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_packed) == 5, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 7, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 32, "");
#endif
_Static_assert(sizeof(V) == 5, "");
_Static_assert(_Alignof(V) == 1, "");
_Static_assert(sizeof(struct V_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_packed) == 5, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 7, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 32, "");
#endif
_Static_assert(sizeof(W) == 17, "");
_Static_assert(_Alignof(W) == 1, "");
_Static_assert(sizeof(struct W_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_packed) == 17, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 19, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 17, "");
_Static_assert(_Alignof(W_) == 1, "");
_Static_assert(sizeof(struct W__extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_packed) == 17, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 19, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 17, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 17, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 19, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 1, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 1, "");
_Static_assert(_Alignof(A_2) == 1, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 1, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 1, "");
_Static_assert(_Alignof(B_2) == 1, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 1, "");
_Static_assert(_Alignof(C22) == 1, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 3, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 4, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 4, "");
_Static_assert(_Alignof(K2) == 4, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct K2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 6, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 4, "");
_Static_assert(_Alignof(Q2) == 4, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 4, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 6, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 1, "");
_Static_assert(_Alignof(R2) == 1, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 3, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 1, "");
_Static_assert(_Alignof(S2) == 1, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 3, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 1, "");
_Static_assert(_Alignof(T2) == 1, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 3, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 1, "");
_Static_assert(_Alignof(U2) == 1, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 3, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 1, "");
_Static_assert(_Alignof(V2) == 1, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 3, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 1, "");
_Static_assert(_Alignof(W2) == 1, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 1, "");
_Static_assert(_Alignof(W_2) == 1, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 1, "");
_Static_assert(_Alignof(X2) == 1, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 3, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 5, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 5, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 7, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 32, "");
#endif
_Static_assert(sizeof(Y2) == 1, "");
_Static_assert(_Alignof(Y2) == 1, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 33, "");
_Static_assert(_Alignof(A3) == 1, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 35, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 33, "");
_Static_assert(_Alignof(A5) == 1, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 35, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 8, "");
_Static_assert(_Alignof(A8) == 4, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A8_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 10, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 12, "");
_Static_assert(_Alignof(A9) == 4, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A9_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 14, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 4, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 6, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 32, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 34, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 128, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|ELEVEN|x86-i686-windows-gnu:Gcc|x86_64-x86_64-windows-gnu:Gcc|END
// repr targets I686PcWindowsGnu|Some("x86-i686-windows-gnu") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu")
#elif defined(ELEVEN)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 5, "");
_Static_assert(_Alignof(A_) == 1, "");
_Static_assert(sizeof(struct A__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_packed) == 5, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 7, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 5, "");
_Static_assert(_Alignof(B_) == 1, "");
_Static_assert(sizeof(struct B__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_packed) == 5, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 7, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 32, "");
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 2, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 3, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 2, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 4, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 8, "");
#endif
_Static_assert(sizeof(D) == 24, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 24, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 26, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 128, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 24, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 24, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 26, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 128, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 192, "");
#endif
_Static_assert(sizeof(M) == 11, "");
_Static_assert(_Alignof(M) == 1, "");
_Static_assert(sizeof(struct M_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_packed) == 11, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 12, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 13, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 80, "");
#endif
_Static_assert(sizeof(N) == 11, "");
_Static_assert(_Alignof(N) == 1, "");
_Static_assert(sizeof(struct N_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_packed) == 11, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 12, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 13, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 80, "");
#endif
_Static_assert(sizeof(O) == 10, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 10, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 12, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 72, "");
#endif
_Static_assert(sizeof(P) == 12, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 12, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 14, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 80, "");
#endif
_Static_assert(sizeof(Q) == 24, "");
_Static_assert(_Alignof(Q) == 8, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q_extra_packed) == 24, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 26, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 128, "");
#endif
_Static_assert(sizeof(R) == 32, "");
_Static_assert(_Alignof(R) == 16, "");
_Static_assert(sizeof(struct R_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 16, "");
_Static_assert(sizeof(struct R_extra_packed) == 32, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 34, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 8, "");
_Static_assert(_Alignof(S) == 8, "");
_Static_assert(sizeof(struct S_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 8, "");
_Static_assert(sizeof(struct S_extra_packed) == 8, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 10, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 16, "");
#endif
_Static_assert(sizeof(T) == 4, "");
_Static_assert(_Alignof(T) == 2, "");
_Static_assert(sizeof(struct T_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 2, "");
_Static_assert(sizeof(struct T_extra_packed) == 4, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 6, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 16, "");
#endif
_Static_assert(sizeof(U) == 8, "");
_Static_assert(_Alignof(U) == 8, "");
_Static_assert(sizeof(struct U_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 8, "");
_Static_assert(sizeof(struct U_extra_packed) == 8, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 10, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 16, "");
#endif
_Static_assert(sizeof(V) == 4, "");
_Static_assert(_Alignof(V) == 2, "");
_Static_assert(sizeof(struct V_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 2, "");
_Static_assert(sizeof(struct V_extra_packed) == 4, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 6, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 16, "");
#endif
_Static_assert(sizeof(W) == 32, "");
_Static_assert(_Alignof(W) == 16, "");
_Static_assert(sizeof(struct W_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 16, "");
_Static_assert(sizeof(struct W_extra_packed) == 32, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 34, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 2, "");
_Static_assert(_Alignof(W_) == 1, "");
_Static_assert(sizeof(struct W__extra_alignment) == 3, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_packed) == 2, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 4, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 8, "");
#endif
_Static_assert(sizeof(X) == 4, "");
_Static_assert(_Alignof(X) == 2, "");
_Static_assert(sizeof(struct X_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 2, "");
_Static_assert(sizeof(struct X_extra_packed) == 4, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 6, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 16, "");
#endif
_Static_assert(sizeof(A2) == 1, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 1, "");
_Static_assert(_Alignof(A_2) == 1, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 1, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 1, "");
_Static_assert(_Alignof(B_2) == 1, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 1, "");
_Static_assert(_Alignof(C22) == 1, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 3, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 8, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 8, "");
_Static_assert(_Alignof(K2) == 8, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 10, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 1, "");
_Static_assert(_Alignof(M2) == 1, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 3, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 1, "");
_Static_assert(_Alignof(N2) == 1, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 3, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 8, "");
_Static_assert(_Alignof(Q2) == 8, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 1, "");
_Static_assert(_Alignof(R2) == 1, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 3, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 1, "");
_Static_assert(_Alignof(S2) == 1, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 3, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 1, "");
_Static_assert(_Alignof(T2) == 1, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 3, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 1, "");
_Static_assert(_Alignof(U2) == 1, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 3, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 1, "");
_Static_assert(_Alignof(V2) == 1, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 3, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 1, "");
_Static_assert(_Alignof(W2) == 1, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 1, "");
_Static_assert(_Alignof(W_2) == 1, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 1, "");
_Static_assert(_Alignof(X2) == 1, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 3, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 8, "");
_Static_assert(_Alignof(Y) == 8, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 10, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 8, "");
#endif
_Static_assert(sizeof(Y2) == 1, "");
_Static_assert(_Alignof(Y2) == 1, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 64, "");
_Static_assert(_Alignof(A3) == 32, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 96, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A3_extra_packed) == 64, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 65, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 66, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 32, "");
_Static_assert(_Alignof(A5) == 32, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A5_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 34, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 8, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 12, "");
_Static_assert(_Alignof(A8) == 4, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A8_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 14, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 40, "");
#endif
_Static_assert(sizeof(A9) == 12, "");
_Static_assert(_Alignof(A9) == 4, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A9_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 14, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 4, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 6, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 16, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 18, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 40, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 16, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 18, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 32, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 33, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 64, "");
#endif
// MAPPING|TWELVE|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|mips-mips32-linux-gnuabi64:Gcc|mips-mips64r6-linux-gnuabi64:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|riscv64-baseline_rv64-linux-gnu:Gcc|s390x-generic-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|END
// repr targets Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") Mipsisa64r6elUnknownLinuxGnuabi64|Some("mips-mips32-linux-gnuabi64") Mipsisa64r6UnknownLinuxGnuabi64|Some("mips-mips64r6-linux-gnuabi64") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl")
#elif defined(TWELVE)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 5, "");
_Static_assert(_Alignof(A_) == 1, "");
_Static_assert(sizeof(struct A__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_packed) == 5, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 7, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 9, "");
_Static_assert(_Alignof(B_) == 1, "");
_Static_assert(sizeof(struct B__extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_packed) == 9, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 11, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 64, "");
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 9, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 9, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 11, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 64, "");
#endif
_Static_assert(sizeof(D) == 24, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 24, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 26, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 128, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 24, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 8, "");
_Static_assert(_Alignof(Q) == 8, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 17, "");
_Static_assert(_Alignof(R) == 1, "");
_Static_assert(sizeof(struct R_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_packed) == 17, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 19, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 9, "");
_Static_assert(_Alignof(S) == 1, "");
_Static_assert(sizeof(struct S_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_packed) == 9, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 11, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 64, "");
#endif
_Static_assert(sizeof(T) == 9, "");
_Static_assert(_Alignof(T) == 1, "");
_Static_assert(sizeof(struct T_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_packed) == 9, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 11, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 64, "");
#endif
_Static_assert(sizeof(U) == 9, "");
_Static_assert(_Alignof(U) == 1, "");
_Static_assert(sizeof(struct U_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_packed) == 9, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 11, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 64, "");
#endif
_Static_assert(sizeof(V) == 9, "");
_Static_assert(_Alignof(V) == 1, "");
_Static_assert(sizeof(struct V_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_packed) == 9, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 11, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 64, "");
#endif
_Static_assert(sizeof(W) == 17, "");
_Static_assert(_Alignof(W) == 1, "");
_Static_assert(sizeof(struct W_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_packed) == 17, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 19, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 17, "");
_Static_assert(_Alignof(W_) == 1, "");
_Static_assert(sizeof(struct W__extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_packed) == 17, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 19, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 17, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 17, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 19, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 1, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 1, "");
_Static_assert(_Alignof(A_2) == 1, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 1, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 1, "");
_Static_assert(_Alignof(B_2) == 1, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 1, "");
_Static_assert(_Alignof(C22) == 1, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 3, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 8, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 8, "");
_Static_assert(_Alignof(K2) == 8, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 10, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 8, "");
_Static_assert(_Alignof(Q2) == 8, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 1, "");
_Static_assert(_Alignof(R2) == 1, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 3, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 1, "");
_Static_assert(_Alignof(S2) == 1, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 3, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 1, "");
_Static_assert(_Alignof(T2) == 1, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 3, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 1, "");
_Static_assert(_Alignof(U2) == 1, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 3, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 1, "");
_Static_assert(_Alignof(V2) == 1, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 3, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 1, "");
_Static_assert(_Alignof(W2) == 1, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 1, "");
_Static_assert(_Alignof(W_2) == 1, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 1, "");
_Static_assert(_Alignof(X2) == 1, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 3, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 9, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 9, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 11, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 64, "");
#endif
_Static_assert(sizeof(Y2) == 1, "");
_Static_assert(_Alignof(Y2) == 1, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 33, "");
_Static_assert(_Alignof(A3) == 1, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 35, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 33, "");
_Static_assert(_Alignof(A5) == 1, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 35, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 8, "");
_Static_assert(_Alignof(A8) == 8, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A8_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 10, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 16, "");
_Static_assert(_Alignof(A9) == 8, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 8, "");
_Static_assert(sizeof(struct A9_extra_packed) == 16, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 18, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 8, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 10, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 32, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 34, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 128, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|THIRTEEN|mipsel-mips32-linux-gnu:Gcc|mipsel-mips32-linux-musl:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32r6-linux-gnu:Gcc|mips-mips32-linux-gnu:Gcc|mips-mips32-linux-musl:Gcc|powerpc-ppc-linux-gnu:Gcc|powerpc-ppc-linux-musl:Gcc|riscv32-baseline_rv32-linux-gnu:Gcc|sparc-v8-linux-gnu:Gcc|x86_64-x86_64-linux-gnux32:Gcc|END
// repr targets MipselUnknownLinuxGnu|Some("mipsel-mips32-linux-gnu") MipselUnknownLinuxMusl|Some("mipsel-mips32-linux-musl") MipselUnknownLinuxUclibc|None Mipsisa32r6elUnknownLinuxGnu|Some("mips-mips32-linux-gnu") Mipsisa32r6UnknownLinuxGnu|Some("mips-mips32r6-linux-gnu") MipsUnknownLinuxGnu|Some("mips-mips32-linux-gnu") MipsUnknownLinuxMusl|Some("mips-mips32-linux-musl") MipsUnknownLinuxUclibc|None PowerpcUnknownLinuxGnu|Some("powerpc-ppc-linux-gnu") PowerpcUnknownLinuxMusl|Some("powerpc-ppc-linux-musl") Riscv32UnknownLinuxGnu|Some("riscv32-baseline_rv32-linux-gnu") SparcUnknownLinuxGnu|Some("sparc-v8-linux-gnu") X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32")
#elif defined(THIRTEEN)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 5, "");
_Static_assert(_Alignof(A_) == 1, "");
_Static_assert(sizeof(struct A__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_packed) == 5, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 7, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 9, "");
_Static_assert(_Alignof(B_) == 1, "");
_Static_assert(sizeof(struct B__extra_alignment) == 10, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_packed) == 9, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 11, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 64, "");
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 9, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 10, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 9, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 11, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 64, "");
#endif
_Static_assert(sizeof(D) == 24, "");
_Static_assert(_Alignof(D) == 8, "");
_Static_assert(sizeof(struct D_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D_extra_packed) == 24, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 25, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 26, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 64, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 128, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 8, "");
_Static_assert(_Alignof(K) == 8, "");
_Static_assert(sizeof(struct K_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 10, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 24, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 8, "");
_Static_assert(_Alignof(Q) == 8, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 17, "");
_Static_assert(_Alignof(R) == 1, "");
_Static_assert(sizeof(struct R_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_packed) == 17, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 19, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 9, "");
_Static_assert(_Alignof(S) == 1, "");
_Static_assert(sizeof(struct S_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_packed) == 9, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 11, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 64, "");
#endif
_Static_assert(sizeof(T) == 9, "");
_Static_assert(_Alignof(T) == 1, "");
_Static_assert(sizeof(struct T_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_packed) == 9, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 11, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 64, "");
#endif
_Static_assert(sizeof(U) == 9, "");
_Static_assert(_Alignof(U) == 1, "");
_Static_assert(sizeof(struct U_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_packed) == 9, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 11, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 64, "");
#endif
_Static_assert(sizeof(V) == 9, "");
_Static_assert(_Alignof(V) == 1, "");
_Static_assert(sizeof(struct V_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_packed) == 9, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 11, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 64, "");
#endif
_Static_assert(sizeof(W) == 17, "");
_Static_assert(_Alignof(W) == 1, "");
_Static_assert(sizeof(struct W_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_packed) == 17, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 19, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 17, "");
_Static_assert(_Alignof(W_) == 1, "");
_Static_assert(sizeof(struct W__extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_packed) == 17, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 19, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 17, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 17, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 19, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 1, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 1, "");
_Static_assert(_Alignof(A_2) == 1, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 1, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 1, "");
_Static_assert(_Alignof(B_2) == 1, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 1, "");
_Static_assert(_Alignof(C22) == 1, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 3, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 8, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 8, "");
_Static_assert(_Alignof(K2) == 8, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct K2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 10, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 8, "");
_Static_assert(_Alignof(Q2) == 8, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 10, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 1, "");
_Static_assert(_Alignof(R2) == 1, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 3, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 1, "");
_Static_assert(_Alignof(S2) == 1, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 3, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 1, "");
_Static_assert(_Alignof(T2) == 1, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 3, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 1, "");
_Static_assert(_Alignof(U2) == 1, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 3, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 1, "");
_Static_assert(_Alignof(V2) == 1, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 3, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 1, "");
_Static_assert(_Alignof(W2) == 1, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 1, "");
_Static_assert(_Alignof(W_2) == 1, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 1, "");
_Static_assert(_Alignof(X2) == 1, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 3, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 9, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 9, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 10, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 11, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 64, "");
#endif
_Static_assert(sizeof(Y2) == 1, "");
_Static_assert(_Alignof(Y2) == 1, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 33, "");
_Static_assert(_Alignof(A3) == 1, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 35, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 33, "");
_Static_assert(_Alignof(A5) == 1, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 35, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 8, "");
_Static_assert(_Alignof(A8) == 4, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A8_extra_packed) == 8, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 10, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 12, "");
_Static_assert(_Alignof(A9) == 4, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 16, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 4, "");
_Static_assert(sizeof(struct A9_extra_packed) == 12, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 14, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 64, "");
#endif
_Static_assert(sizeof(A10) == 4, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 6, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 32, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 34, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 128, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
// MAPPING|FOURTEEN|msp430-msp430-other-eabi:Clang|END
// repr targets Msp430NoneElf|Some("msp430-msp430-other-eabi")
#elif defined(FOURTEEN)
_Static_assert(sizeof(A) == 1, "");
_Static_assert(_Alignof(A) == 1, "");
_Static_assert(sizeof(struct A_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A,d) == 0, "");
#endif
_Static_assert(sizeof(A_) == 5, "");
_Static_assert(_Alignof(A_) == 1, "");
_Static_assert(sizeof(struct A__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_packed) == 5, "");
_Static_assert(_Alignof(struct A__extra_packed) == 1, "");
_Static_assert(sizeof(struct A__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct A__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A__extra_size) == 7, "");
_Static_assert(_Alignof(struct A__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_,d) == 32, "");
#endif
_Static_assert(sizeof(B) == 1, "");
_Static_assert(_Alignof(B) == 1, "");
_Static_assert(sizeof(struct B_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B,d) == 0, "");
#endif
_Static_assert(sizeof(B_) == 5, "");
_Static_assert(_Alignof(B_) == 1, "");
_Static_assert(sizeof(struct B__extra_alignment) == 6, "");
_Static_assert(_Alignof(struct B__extra_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_packed) == 5, "");
_Static_assert(_Alignof(struct B__extra_packed) == 1, "");
_Static_assert(sizeof(struct B__extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct B__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B__extra_size) == 7, "");
_Static_assert(_Alignof(struct B__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_,d) == 32, "");
#endif
_Static_assert(sizeof(C) == 1, "");
_Static_assert(_Alignof(C) == 1, "");
_Static_assert(sizeof(struct C_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C_extra_packed) == 1, "");
_Static_assert(sizeof(struct C_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C_extra_size) == 3, "");
_Static_assert(_Alignof(struct C_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C,d) == 0, "");
#endif
_Static_assert(sizeof(C_) == 3, "");
_Static_assert(_Alignof(C_) == 1, "");
_Static_assert(sizeof(struct C__extra_alignment) == 4, "");
_Static_assert(_Alignof(struct C__extra_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_packed) == 3, "");
_Static_assert(_Alignof(struct C__extra_packed) == 1, "");
_Static_assert(sizeof(struct C__extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct C__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C__extra_size) == 5, "");
_Static_assert(_Alignof(struct C__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C_,d) == 16, "");
#endif
_Static_assert(sizeof(D) == 12, "");
_Static_assert(_Alignof(D) == 2, "");
_Static_assert(sizeof(struct D_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct D_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D_extra_packed) == 12, "");
_Static_assert(_Alignof(struct D_extra_packed) == 1, "");
_Static_assert(sizeof(struct D_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct D_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D_extra_size) == 14, "");
_Static_assert(_Alignof(struct D_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(D,e) == 80, "");
#endif
_Static_assert(sizeof(F) == 32, "");
_Static_assert(_Alignof(F) == 16, "");
_Static_assert(sizeof(struct F_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct F_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F_extra_packed) == 32, "");
_Static_assert(_Alignof(struct F_extra_packed) == 1, "");
_Static_assert(sizeof(struct F_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct F_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F_extra_size) == 34, "");
_Static_assert(_Alignof(struct F_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(F,e) == 192, "");
#endif
_Static_assert(sizeof(G) == 12, "");
_Static_assert(_Alignof(G) == 2, "");
_Static_assert(sizeof(struct G_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct G_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G_extra_packed) == 12, "");
_Static_assert(_Alignof(struct G_extra_packed) == 1, "");
_Static_assert(sizeof(struct G_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct G_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G_extra_size) == 14, "");
_Static_assert(_Alignof(struct G_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(G,e) == 80, "");
#endif
_Static_assert(sizeof(H) == 12, "");
_Static_assert(_Alignof(H) == 2, "");
_Static_assert(sizeof(struct H_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct H_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H_extra_packed) == 12, "");
_Static_assert(_Alignof(struct H_extra_packed) == 1, "");
_Static_assert(sizeof(struct H_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct H_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H_extra_size) == 14, "");
_Static_assert(_Alignof(struct H_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(H,e) == 80, "");
#endif
_Static_assert(sizeof(I) == 10, "");
_Static_assert(_Alignof(I) == 1, "");
_Static_assert(sizeof(struct I_extra_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_packed) == 10, "");
_Static_assert(_Alignof(struct I_extra_packed) == 1, "");
_Static_assert(sizeof(struct I_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct I_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I_extra_size) == 12, "");
_Static_assert(_Alignof(struct I_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(I,e) == 72, "");
#endif
_Static_assert(sizeof(J) == 12, "");
_Static_assert(_Alignof(J) == 2, "");
_Static_assert(sizeof(struct J_extra_alignment) == 14, "");
_Static_assert(_Alignof(struct J_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J_extra_packed) == 12, "");
_Static_assert(_Alignof(struct J_extra_packed) == 1, "");
_Static_assert(sizeof(struct J_extra_required_alignment) == 13, "");
_Static_assert(_Alignof(struct J_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J_extra_size) == 14, "");
_Static_assert(_Alignof(struct J_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(J,e) == 80, "");
#endif
_Static_assert(sizeof(K) == 4, "");
_Static_assert(_Alignof(K) == 2, "");
_Static_assert(sizeof(struct K_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct K_extra_alignment) == 2, "");
_Static_assert(sizeof(struct K_extra_packed) == 4, "");
_Static_assert(_Alignof(struct K_extra_packed) == 1, "");
_Static_assert(sizeof(struct K_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct K_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K_extra_size) == 6, "");
_Static_assert(_Alignof(struct K_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(K,e) == 16, "");
#endif
_Static_assert(sizeof(L) == 32, "");
_Static_assert(_Alignof(L) == 16, "");
_Static_assert(sizeof(struct L_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct L_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L_extra_packed) == 32, "");
_Static_assert(_Alignof(struct L_extra_packed) == 1, "");
_Static_assert(sizeof(struct L_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct L_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L_extra_size) == 34, "");
_Static_assert(_Alignof(struct L_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L,d) == 128, "");
_Static_assert(__builtin_bitoffsetof(L,e) == 136, "");
#endif
_Static_assert(sizeof(M) == 4, "");
_Static_assert(_Alignof(M) == 2, "");
_Static_assert(sizeof(struct M_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct M_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M_extra_packed) == 4, "");
_Static_assert(_Alignof(struct M_extra_packed) == 1, "");
_Static_assert(sizeof(struct M_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct M_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M_extra_size) == 6, "");
_Static_assert(_Alignof(struct M_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M,d) == 16, "");
_Static_assert(__builtin_bitoffsetof(M,e) == 24, "");
#endif
_Static_assert(sizeof(N) == 4, "");
_Static_assert(_Alignof(N) == 2, "");
_Static_assert(sizeof(struct N_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct N_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N_extra_packed) == 4, "");
_Static_assert(_Alignof(struct N_extra_packed) == 1, "");
_Static_assert(sizeof(struct N_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct N_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N_extra_size) == 6, "");
_Static_assert(_Alignof(struct N_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(N,e) == 16, "");
#endif
_Static_assert(sizeof(O) == 3, "");
_Static_assert(_Alignof(O) == 1, "");
_Static_assert(sizeof(struct O_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_packed) == 3, "");
_Static_assert(_Alignof(struct O_extra_packed) == 1, "");
_Static_assert(sizeof(struct O_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct O_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O_extra_size) == 5, "");
_Static_assert(_Alignof(struct O_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(O,e) == 16, "");
#endif
_Static_assert(sizeof(P) == 4, "");
_Static_assert(_Alignof(P) == 2, "");
_Static_assert(sizeof(struct P_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct P_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P_extra_packed) == 4, "");
_Static_assert(_Alignof(struct P_extra_packed) == 1, "");
_Static_assert(sizeof(struct P_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct P_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P_extra_size) == 6, "");
_Static_assert(_Alignof(struct P_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P,d) == 8, "");
_Static_assert(__builtin_bitoffsetof(P,e) == 16, "");
#endif
_Static_assert(sizeof(Q) == 4, "");
_Static_assert(_Alignof(Q) == 2, "");
_Static_assert(sizeof(struct Q_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct Q_extra_alignment) == 2, "");
_Static_assert(sizeof(struct Q_extra_packed) == 4, "");
_Static_assert(_Alignof(struct Q_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct Q_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q_extra_size) == 6, "");
_Static_assert(_Alignof(struct Q_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(Q,d) == 9, "");
_Static_assert(__builtin_bitoffsetof(Q,e) == 16, "");
#endif
_Static_assert(sizeof(R) == 17, "");
_Static_assert(_Alignof(R) == 1, "");
_Static_assert(sizeof(struct R_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_packed) == 17, "");
_Static_assert(_Alignof(struct R_extra_packed) == 1, "");
_Static_assert(sizeof(struct R_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct R_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R_extra_size) == 19, "");
_Static_assert(_Alignof(struct R_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(R,e) == 128, "");
#endif
_Static_assert(sizeof(S) == 3, "");
_Static_assert(_Alignof(S) == 1, "");
_Static_assert(sizeof(struct S_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct S_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_packed) == 3, "");
_Static_assert(_Alignof(struct S_extra_packed) == 1, "");
_Static_assert(sizeof(struct S_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct S_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S_extra_size) == 5, "");
_Static_assert(_Alignof(struct S_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(S,e) == 16, "");
#endif
_Static_assert(sizeof(T) == 5, "");
_Static_assert(_Alignof(T) == 1, "");
_Static_assert(sizeof(struct T_extra_alignment) == 6, "");
_Static_assert(_Alignof(struct T_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_packed) == 5, "");
_Static_assert(_Alignof(struct T_extra_packed) == 1, "");
_Static_assert(sizeof(struct T_extra_required_alignment) == 6, "");
_Static_assert(_Alignof(struct T_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T_extra_size) == 7, "");
_Static_assert(_Alignof(struct T_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(T,e) == 32, "");
#endif
_Static_assert(sizeof(U) == 3, "");
_Static_assert(_Alignof(U) == 1, "");
_Static_assert(sizeof(struct U_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct U_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_packed) == 3, "");
_Static_assert(_Alignof(struct U_extra_packed) == 1, "");
_Static_assert(sizeof(struct U_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct U_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U_extra_size) == 5, "");
_Static_assert(_Alignof(struct U_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(U,e) == 16, "");
#endif
_Static_assert(sizeof(V) == 3, "");
_Static_assert(_Alignof(V) == 1, "");
_Static_assert(sizeof(struct V_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct V_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_packed) == 3, "");
_Static_assert(_Alignof(struct V_extra_packed) == 1, "");
_Static_assert(sizeof(struct V_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct V_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V_extra_size) == 5, "");
_Static_assert(_Alignof(struct V_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(V,e) == 16, "");
#endif
_Static_assert(sizeof(W) == 17, "");
_Static_assert(_Alignof(W) == 1, "");
_Static_assert(sizeof(struct W_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_packed) == 17, "");
_Static_assert(_Alignof(struct W_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_extra_size) == 19, "");
_Static_assert(_Alignof(struct W_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(W,e) == 128, "");
#endif
_Static_assert(sizeof(W_) == 17, "");
_Static_assert(_Alignof(W_) == 1, "");
_Static_assert(sizeof(struct W__extra_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_packed) == 17, "");
_Static_assert(_Alignof(struct W__extra_packed) == 1, "");
_Static_assert(sizeof(struct W__extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct W__extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W__extra_size) == 19, "");
_Static_assert(_Alignof(struct W__extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_,e) == 128, "");
#endif
_Static_assert(sizeof(X) == 17, "");
_Static_assert(_Alignof(X) == 1, "");
_Static_assert(sizeof(struct X_extra_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_packed) == 17, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 18, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 19, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X,x) == 8, "");
_Static_assert(__builtin_bitoffsetof(X,e) == 128, "");
#endif
_Static_assert(sizeof(A2) == 1, "");
_Static_assert(_Alignof(A2) == 1, "");
_Static_assert(sizeof(struct A2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A2,d) == 0, "");
#endif
_Static_assert(sizeof(A_2) == 1, "");
_Static_assert(_Alignof(A_2) == 1, "");
_Static_assert(sizeof(struct A_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct A_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct A_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A_2,d) == 0, "");
#endif
_Static_assert(sizeof(B2) == 1, "");
_Static_assert(_Alignof(B2) == 1, "");
_Static_assert(sizeof(struct B2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B2,d) == 0, "");
#endif
_Static_assert(sizeof(B_2) == 1, "");
_Static_assert(_Alignof(B_2) == 1, "");
_Static_assert(sizeof(struct B_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct B_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct B_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct B_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct B_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct B_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(B_2,d) == 0, "");
#endif
_Static_assert(sizeof(C2) == 1, "");
_Static_assert(_Alignof(C2) == 1, "");
_Static_assert(sizeof(struct C2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C2_extra_packed) == 1, "");
_Static_assert(sizeof(struct C2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C2_extra_size) == 3, "");
_Static_assert(_Alignof(struct C2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C2,d) == 0, "");
#endif
_Static_assert(sizeof(C22) == 1, "");
_Static_assert(_Alignof(C22) == 1, "");
_Static_assert(sizeof(struct C22_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_packed) == 1, "");
_Static_assert(_Alignof(struct C22_extra_packed) == 1, "");
_Static_assert(sizeof(struct C22_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct C22_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct C22_extra_size) == 3, "");
_Static_assert(_Alignof(struct C22_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(C22,d) == 0, "");
#endif
_Static_assert(sizeof(D2) == 8, "");
_Static_assert(_Alignof(D2) == 2, "");
_Static_assert(sizeof(struct D2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct D2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct D2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct D2_extra_packed) == 1, "");
_Static_assert(sizeof(struct D2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct D2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct D2_extra_size) == 10, "");
_Static_assert(_Alignof(struct D2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(D2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(D2,e) == 0, "");
#endif
_Static_assert(sizeof(F2) == 16, "");
_Static_assert(_Alignof(F2) == 16, "");
_Static_assert(sizeof(struct F2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct F2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct F2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct F2_extra_packed) == 1, "");
_Static_assert(sizeof(struct F2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct F2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct F2_extra_size) == 18, "");
_Static_assert(_Alignof(struct F2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(F2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(F2,e) == 0, "");
#endif
_Static_assert(sizeof(G2) == 8, "");
_Static_assert(_Alignof(G2) == 2, "");
_Static_assert(sizeof(struct G2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct G2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct G2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct G2_extra_packed) == 1, "");
_Static_assert(sizeof(struct G2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct G2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct G2_extra_size) == 10, "");
_Static_assert(_Alignof(struct G2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(G2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(G2,e) == 0, "");
#endif
_Static_assert(sizeof(H2) == 8, "");
_Static_assert(_Alignof(H2) == 2, "");
_Static_assert(sizeof(struct H2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct H2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct H2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct H2_extra_packed) == 1, "");
_Static_assert(sizeof(struct H2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct H2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct H2_extra_size) == 10, "");
_Static_assert(_Alignof(struct H2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(H2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(H2,e) == 0, "");
#endif
_Static_assert(sizeof(I2) == 8, "");
_Static_assert(_Alignof(I2) == 1, "");
_Static_assert(sizeof(struct I2_extra_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct I2_extra_packed) == 1, "");
_Static_assert(sizeof(struct I2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct I2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct I2_extra_size) == 10, "");
_Static_assert(_Alignof(struct I2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(I2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(I2,e) == 0, "");
#endif
_Static_assert(sizeof(J2) == 8, "");
_Static_assert(_Alignof(J2) == 2, "");
_Static_assert(sizeof(struct J2_extra_alignment) == 10, "");
_Static_assert(_Alignof(struct J2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct J2_extra_packed) == 8, "");
_Static_assert(_Alignof(struct J2_extra_packed) == 1, "");
_Static_assert(sizeof(struct J2_extra_required_alignment) == 9, "");
_Static_assert(_Alignof(struct J2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct J2_extra_size) == 10, "");
_Static_assert(_Alignof(struct J2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(J2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(J2,e) == 0, "");
#endif
_Static_assert(sizeof(K2) == 2, "");
_Static_assert(_Alignof(K2) == 2, "");
_Static_assert(sizeof(struct K2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct K2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct K2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct K2_extra_packed) == 1, "");
_Static_assert(sizeof(struct K2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct K2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct K2_extra_size) == 4, "");
_Static_assert(_Alignof(struct K2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(K2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(K2,e) == 0, "");
#endif
_Static_assert(sizeof(L2) == 16, "");
_Static_assert(_Alignof(L2) == 16, "");
_Static_assert(sizeof(struct L2_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct L2_extra_alignment) == 16, "");
_Static_assert(sizeof(struct L2_extra_packed) == 16, "");
_Static_assert(_Alignof(struct L2_extra_packed) == 1, "");
_Static_assert(sizeof(struct L2_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct L2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct L2_extra_size) == 18, "");
_Static_assert(_Alignof(struct L2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(L2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(L2,e) == 0, "");
#endif
_Static_assert(sizeof(M2) == 2, "");
_Static_assert(_Alignof(M2) == 2, "");
_Static_assert(sizeof(struct M2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct M2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct M2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct M2_extra_packed) == 1, "");
_Static_assert(sizeof(struct M2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct M2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct M2_extra_size) == 4, "");
_Static_assert(_Alignof(struct M2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(M2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(M2,e) == 0, "");
#endif
_Static_assert(sizeof(N2) == 2, "");
_Static_assert(_Alignof(N2) == 2, "");
_Static_assert(sizeof(struct N2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct N2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct N2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct N2_extra_packed) == 1, "");
_Static_assert(sizeof(struct N2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct N2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct N2_extra_size) == 4, "");
_Static_assert(_Alignof(struct N2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(N2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(N2,e) == 0, "");
#endif
_Static_assert(sizeof(O2) == 1, "");
_Static_assert(_Alignof(O2) == 1, "");
_Static_assert(sizeof(struct O2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct O2_extra_packed) == 1, "");
_Static_assert(sizeof(struct O2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct O2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct O2_extra_size) == 3, "");
_Static_assert(_Alignof(struct O2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(O2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(O2,e) == 0, "");
#endif
_Static_assert(sizeof(P2) == 2, "");
_Static_assert(_Alignof(P2) == 2, "");
_Static_assert(sizeof(struct P2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct P2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct P2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct P2_extra_packed) == 1, "");
_Static_assert(sizeof(struct P2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct P2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct P2_extra_size) == 4, "");
_Static_assert(_Alignof(struct P2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(P2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(P2,e) == 0, "");
#endif
_Static_assert(sizeof(Q2) == 2, "");
_Static_assert(_Alignof(Q2) == 2, "");
_Static_assert(sizeof(struct Q2_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct Q2_extra_alignment) == 2, "");
_Static_assert(sizeof(struct Q2_extra_packed) == 2, "");
_Static_assert(_Alignof(struct Q2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Q2_extra_required_alignment) == 3, "");
_Static_assert(_Alignof(struct Q2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Q2_extra_size) == 4, "");
_Static_assert(_Alignof(struct Q2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Q2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,d) == 0, "");
_Static_assert(__builtin_bitoffsetof(Q2,e) == 0, "");
#endif
_Static_assert(sizeof(R2) == 1, "");
_Static_assert(_Alignof(R2) == 1, "");
_Static_assert(sizeof(struct R2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct R2_extra_packed) == 1, "");
_Static_assert(sizeof(struct R2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct R2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct R2_extra_size) == 3, "");
_Static_assert(_Alignof(struct R2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(R2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(R2,e) == 0, "");
#endif
_Static_assert(sizeof(S2) == 1, "");
_Static_assert(_Alignof(S2) == 1, "");
_Static_assert(sizeof(struct S2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct S2_extra_packed) == 1, "");
_Static_assert(sizeof(struct S2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct S2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct S2_extra_size) == 3, "");
_Static_assert(_Alignof(struct S2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(S2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(S2,e) == 0, "");
#endif
_Static_assert(sizeof(T2) == 1, "");
_Static_assert(_Alignof(T2) == 1, "");
_Static_assert(sizeof(struct T2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct T2_extra_packed) == 1, "");
_Static_assert(sizeof(struct T2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct T2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct T2_extra_size) == 3, "");
_Static_assert(_Alignof(struct T2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(T2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(T2,e) == 0, "");
#endif
_Static_assert(sizeof(U2) == 1, "");
_Static_assert(_Alignof(U2) == 1, "");
_Static_assert(sizeof(struct U2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct U2_extra_packed) == 1, "");
_Static_assert(sizeof(struct U2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct U2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct U2_extra_size) == 3, "");
_Static_assert(_Alignof(struct U2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(U2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(U2,e) == 0, "");
#endif
_Static_assert(sizeof(V2) == 1, "");
_Static_assert(_Alignof(V2) == 1, "");
_Static_assert(sizeof(struct V2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct V2_extra_packed) == 1, "");
_Static_assert(sizeof(struct V2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct V2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct V2_extra_size) == 3, "");
_Static_assert(_Alignof(struct V2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(V2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(V2,e) == 0, "");
#endif
_Static_assert(sizeof(W2) == 1, "");
_Static_assert(_Alignof(W2) == 1, "");
_Static_assert(sizeof(struct W2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(W2,e) == 0, "");
#endif
_Static_assert(sizeof(W_2) == 1, "");
_Static_assert(_Alignof(W_2) == 1, "");
_Static_assert(sizeof(struct W_2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct W_2_extra_packed) == 1, "");
_Static_assert(sizeof(struct W_2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct W_2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct W_2_extra_size) == 3, "");
_Static_assert(_Alignof(struct W_2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(W_2,e) == 0, "");
#endif
_Static_assert(sizeof(X2) == 1, "");
_Static_assert(_Alignof(X2) == 1, "");
_Static_assert(sizeof(struct X2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct X2_extra_packed) == 1, "");
_Static_assert(sizeof(struct X2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct X2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X2_extra_size) == 3, "");
_Static_assert(_Alignof(struct X2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(X2,x) == 0, "");
_Static_assert(__builtin_bitoffsetof(X2,e) == 0, "");
#endif
_Static_assert(sizeof(Y) == 3, "");
_Static_assert(_Alignof(Y) == 1, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 4, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_packed) == 3, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 4, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 5, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y,d) == 16, "");
#endif
_Static_assert(sizeof(Y2) == 1, "");
_Static_assert(_Alignof(Y2) == 1, "");
_Static_assert(sizeof(struct Y2_extra_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_packed) == 1, "");
_Static_assert(_Alignof(struct Y2_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y2_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct Y2_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y2_extra_size) == 3, "");
_Static_assert(_Alignof(struct Y2_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(Y2,d) == 0, "");
#endif
_Static_assert(sizeof(A3) == 33, "");
_Static_assert(_Alignof(A3) == 1, "");
_Static_assert(sizeof(struct A3_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A3_extra_packed) == 1, "");
_Static_assert(sizeof(struct A3_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A3_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A3_extra_size) == 35, "");
_Static_assert(_Alignof(struct A3_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A3,d) == 256, "");
#endif
_Static_assert(sizeof(A4) == 1, "");
_Static_assert(_Alignof(A4) == 32, "");
_Static_assert(sizeof(struct A4_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A4_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A4_extra_packed) == 1, "");
_Static_assert(_Alignof(struct A4_extra_packed) == 1, "");
_Static_assert(sizeof(struct A4_extra_required_alignment) == 2, "");
_Static_assert(_Alignof(struct A4_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A4_extra_size) == 3, "");
_Static_assert(_Alignof(struct A4_extra_size) == 1, "");
_Static_assert(sizeof(A5) == 33, "");
_Static_assert(_Alignof(A5) == 1, "");
_Static_assert(sizeof(struct A5_extra_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_packed) == 33, "");
_Static_assert(_Alignof(struct A5_extra_packed) == 1, "");
_Static_assert(sizeof(struct A5_extra_required_alignment) == 34, "");
_Static_assert(_Alignof(struct A5_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A5_extra_size) == 35, "");
_Static_assert(_Alignof(struct A5_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A5,d) == 256, "");
#endif
_Static_assert(sizeof(A7) == 32, "");
_Static_assert(_Alignof(A7) == 32, "");
_Static_assert(sizeof(struct A7_extra_alignment) == 64, "");
_Static_assert(_Alignof(struct A7_extra_alignment) == 32, "");
_Static_assert(sizeof(struct A7_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A7_extra_packed) == 1, "");
_Static_assert(sizeof(struct A7_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A7_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A7_extra_size) == 34, "");
_Static_assert(_Alignof(struct A7_extra_size) == 1, "");
_Static_assert(sizeof(A8) == 6, "");
_Static_assert(_Alignof(A8) == 2, "");
_Static_assert(sizeof(struct A8_extra_alignment) == 8, "");
_Static_assert(_Alignof(struct A8_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A8_extra_packed) == 6, "");
_Static_assert(_Alignof(struct A8_extra_packed) == 1, "");
_Static_assert(sizeof(struct A8_extra_required_alignment) == 7, "");
_Static_assert(_Alignof(struct A8_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A8_extra_size) == 8, "");
_Static_assert(_Alignof(struct A8_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A8,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A8,j) == 39, "");
#endif
_Static_assert(sizeof(A9) == 10, "");
_Static_assert(_Alignof(A9) == 2, "");
_Static_assert(sizeof(struct A9_extra_alignment) == 12, "");
_Static_assert(_Alignof(struct A9_extra_alignment) == 2, "");
_Static_assert(sizeof(struct A9_extra_packed) == 10, "");
_Static_assert(_Alignof(struct A9_extra_packed) == 1, "");
_Static_assert(sizeof(struct A9_extra_required_alignment) == 11, "");
_Static_assert(_Alignof(struct A9_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A9_extra_size) == 12, "");
_Static_assert(_Alignof(struct A9_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A9,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A9,j) == 48, "");
#endif
_Static_assert(sizeof(A10) == 4, "");
_Static_assert(_Alignof(A10) == 16, "");
_Static_assert(sizeof(struct A10_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct A10_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A10_extra_packed) == 4, "");
_Static_assert(_Alignof(struct A10_extra_packed) == 1, "");
_Static_assert(sizeof(struct A10_extra_required_alignment) == 5, "");
_Static_assert(_Alignof(struct A10_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A10_extra_size) == 6, "");
_Static_assert(_Alignof(struct A10_extra_size) == 1, "");
_Static_assert(sizeof(A11) == 32, "");
_Static_assert(_Alignof(A11) == 16, "");
_Static_assert(sizeof(struct A11_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A11_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A11_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A11_extra_packed) == 1, "");
_Static_assert(sizeof(struct A11_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A11_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A11_extra_size) == 34, "");
_Static_assert(_Alignof(struct A11_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A11,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A11,j) == 128, "");
#endif
_Static_assert(sizeof(A12) == 32, "");
_Static_assert(_Alignof(A12) == 16, "");
_Static_assert(sizeof(struct A12_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A12_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A12_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A12_extra_packed) == 1, "");
_Static_assert(sizeof(struct A12_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A12_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A12_extra_size) == 34, "");
_Static_assert(_Alignof(struct A12_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A12,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A12,j) == 128, "");
#endif
_Static_assert(sizeof(A13) == 32, "");
_Static_assert(_Alignof(A13) == 16, "");
_Static_assert(sizeof(struct A13_extra_alignment) == 48, "");
_Static_assert(_Alignof(struct A13_extra_alignment) == 16, "");
_Static_assert(sizeof(struct A13_extra_packed) == 32, "");
_Static_assert(_Alignof(struct A13_extra_packed) == 1, "");
_Static_assert(sizeof(struct A13_extra_required_alignment) == 33, "");
_Static_assert(_Alignof(struct A13_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct A13_extra_size) == 34, "");
_Static_assert(_Alignof(struct A13_extra_size) == 1, "");
#ifndef SKIP_OFFSETS
_Static_assert(__builtin_bitoffsetof(A13,i) == 8, "");
_Static_assert(__builtin_bitoffsetof(A13,j) == 128, "");
_Static_assert(__builtin_bitoffsetof(A13,d) == 136, "");
#endif
#endif
|
0 | repos/arocc/test | repos/arocc/test/records/0050_test.c | // SPDX-License-Identifier: GPL-3.0-or-later
// This test file is auto-generated. do not edit.
// This file is a derivative work from the test files found
// in this repo : https://github.com/mahkoh/repr-c
// and is under the same licence as the original work.
typedef __int128 X;
X var1;
struct X_extra_alignment {
char a;
X b;
};
struct X_extra_alignment var2;
#pragma pack(1)
struct X_extra_packed {
X a;
};
#pragma pack()
struct X_extra_required_alignment {
char a;
struct X_extra_packed b;
};
struct X_extra_required_alignment var3;
struct X_extra_size {
char a[sizeof(X)+1];
char b;
};
struct X_extra_size var4;
typedef unsigned __int128 Y;
Y var5;
struct Y_extra_alignment {
char a;
Y b;
};
struct Y_extra_alignment var6;
#pragma pack(1)
struct Y_extra_packed {
Y a;
};
#pragma pack()
struct Y_extra_required_alignment {
char a;
struct Y_extra_packed b;
};
struct Y_extra_required_alignment var7;
struct Y_extra_size {
char a[sizeof(Y)+1];
char b;
};
struct Y_extra_size var8;
// MAPPING|ONE|aarch64-generic-macos-none:Clang|aarch64-generic-fuchsia-gnu:Clang|aarch64-generic-linux-android:Clang|aarch64-generic-freebsd-gnu:Clang|aarch64-generic-hermit-eabi:Clang|aarch64-generic-linux-gnu:Gcc|aarch64-generic-linux-musl:Gcc|aarch64-generic-netbsd-gnu:Clang|aarch64-generic-other-none:Clang|aarch64-generic-openbsd-gnu:Clang|aarch64-generic-ios-none:Clang|aarch64-generic-ios-macabi:Clang|aarch64-generic-tvos-none:Clang|mips64el-mips64-linux-gnuabi64:Gcc|mips64el-mips64-linux-musl:Gcc|mips64-mips64-linux-gnuabi64:Gcc|mips64-mips64-linux-musl:Gcc|powerpc64le-ppc64le-linux-gnu:Gcc|powerpc64le-ppc64le-linux-musl:Gcc|powerpc64-ppc64-freebsd-gnu:Clang|powerpc64-ppc64-linux-gnu:Gcc|powerpc64-ppc64-linux-musl:Gcc|riscv64-baseline_rv64-other-eabi:Clang|riscv64-baseline_rv64-linux-gnu:Gcc|sparc64-v9-linux-gnu:Gcc|sparc64-v9-netbsd-gnu:Clang|sparc64-v9-openbsd-gnu:Clang|wasm32-generic-emscripten-musl:Clang|wasm32-generic-other-musl:Clang|wasm32-generic-wasi-musl:Clang|x86_64-x86_64-ios-macabi:Clang|x86_64-x86_64-ios-none:Clang|x86_64-x86_64-macos-none:Clang|x86_64-x86_64-tvos-none:Clang|x86_64-x86_64-other-eabi:Clang|x86_64-x86_64-fuchsia-gnu:Clang|x86_64-x86_64-linux-android:Clang|x86_64-x86_64-solaris-eabi:Clang|x86_64-x86_64-windows-gnu:Gcc|x86_64-x86_64-dragonfly-eabi:Clang|x86_64-x86_64-freebsd-gnu:Clang|x86_64-x86_64-haiku-gnu:Clang|x86_64-x86_64-hermit-eabi:Clang|x86_64-x86_64-linux-gnux32:Gcc|x86_64-x86_64-linux-gnu:Gcc|x86_64-x86_64-linux-musl:Gcc|x86_64-x86_64-netbsd-gnu:Clang|x86_64-x86_64-openbsd-gnu:Clang|END
// repr targets Aarch64AppleMacosx|Some("aarch64-generic-macos-none") Aarch64Fuchsia|Some("aarch64-generic-fuchsia-gnu") Aarch64LinuxAndroid|Some("aarch64-generic-linux-android") Aarch64UnknownFreebsd|Some("aarch64-generic-freebsd-gnu") Aarch64UnknownHermit|Some("aarch64-generic-hermit-eabi") Aarch64UnknownLinuxGnu|Some("aarch64-generic-linux-gnu") Aarch64UnknownLinuxMusl|Some("aarch64-generic-linux-musl") Aarch64UnknownNetbsd|Some("aarch64-generic-netbsd-gnu") Aarch64UnknownNone|Some("aarch64-generic-other-none") Aarch64UnknownOpenbsd|Some("aarch64-generic-openbsd-gnu") Aarch64UnknownRedox|None Arm64AppleIos|Some("aarch64-generic-ios-none") Arm64AppleIosMacabi|Some("aarch64-generic-ios-macabi") Arm64AppleTvos|Some("aarch64-generic-tvos-none") Mips64elUnknownLinuxGnuabi64|Some("mips64el-mips64-linux-gnuabi64") Mips64elUnknownLinuxMusl|Some("mips64el-mips64-linux-musl") Mips64UnknownLinuxGnuabi64|Some("mips64-mips64-linux-gnuabi64") Mips64UnknownLinuxMusl|Some("mips64-mips64-linux-musl") Powerpc64leUnknownLinuxGnu|Some("powerpc64le-ppc64le-linux-gnu") Powerpc64leUnknownLinuxMusl|Some("powerpc64le-ppc64le-linux-musl") Powerpc64UnknownFreebsd|Some("powerpc64-ppc64-freebsd-gnu") Powerpc64UnknownLinuxGnu|Some("powerpc64-ppc64-linux-gnu") Powerpc64UnknownLinuxMusl|Some("powerpc64-ppc64-linux-musl") Riscv64|Some("riscv64-baseline_rv64-other-eabi") Riscv64UnknownLinuxGnu|Some("riscv64-baseline_rv64-linux-gnu") Sparc64UnknownLinuxGnu|Some("sparc64-v9-linux-gnu") Sparc64UnknownNetbsd|Some("sparc64-v9-netbsd-gnu") Sparc64UnknownOpenbsd|Some("sparc64-v9-openbsd-gnu") Wasm32UnknownEmscripten|Some("wasm32-generic-emscripten-musl") Wasm32UnknownUnknown|Some("wasm32-generic-other-musl") Wasm32Wasi|Some("wasm32-generic-wasi-musl") X86_64AppleIosMacabi|Some("x86_64-x86_64-ios-macabi") X86_64AppleIos|Some("x86_64-x86_64-ios-none") X86_64AppleMacosx|Some("x86_64-x86_64-macos-none") X86_64AppleTvos|Some("x86_64-x86_64-tvos-none") X86_64Elf|Some("x86_64-x86_64-other-eabi") X86_64Fuchsia|Some("x86_64-x86_64-fuchsia-gnu") X86_64LinuxAndroid|Some("x86_64-x86_64-linux-android") X86_64PcSolaris|Some("x86_64-x86_64-solaris-eabi") X86_64PcWindowsGnu|Some("x86_64-x86_64-windows-gnu") X86_64RumprunNetbsd|None X86_64UnknownDragonfly|Some("x86_64-x86_64-dragonfly-eabi") X86_64UnknownFreebsd|Some("x86_64-x86_64-freebsd-gnu") X86_64UnknownHaiku|Some("x86_64-x86_64-haiku-gnu") X86_64UnknownHermit|Some("x86_64-x86_64-hermit-eabi") X86_64UnknownL4reUclibc|None X86_64UnknownLinuxGnux32|Some("x86_64-x86_64-linux-gnux32") X86_64UnknownLinuxGnu|Some("x86_64-x86_64-linux-gnu") X86_64UnknownLinuxMusl|Some("x86_64-x86_64-linux-musl") X86_64UnknownNetbsd|Some("x86_64-x86_64-netbsd-gnu") X86_64UnknownOpenbsd|Some("x86_64-x86_64-openbsd-gnu") X86_64UnknownRedox|None
#ifdef ONE
_Static_assert(sizeof(X) == 16, "");
_Static_assert(_Alignof(X) == 16, "");
_Static_assert(sizeof(struct X_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 16, "");
_Static_assert(sizeof(struct X_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 18, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 16, "");
_Static_assert(_Alignof(Y) == 16, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 32, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 16, "");
_Static_assert(sizeof(struct Y_extra_packed) == 16, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 18, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
// MAPPING|TWO|s390x-generic-linux-gnu:Gcc|END
// repr targets S390xUnknownLinuxGnu|Some("s390x-generic-linux-gnu")
#elif defined(TWO)
_Static_assert(sizeof(X) == 16, "");
_Static_assert(_Alignof(X) == 8, "");
_Static_assert(sizeof(struct X_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct X_extra_alignment) == 8, "");
_Static_assert(sizeof(struct X_extra_packed) == 16, "");
_Static_assert(_Alignof(struct X_extra_packed) == 1, "");
_Static_assert(sizeof(struct X_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct X_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct X_extra_size) == 18, "");
_Static_assert(_Alignof(struct X_extra_size) == 1, "");
_Static_assert(sizeof(Y) == 16, "");
_Static_assert(_Alignof(Y) == 8, "");
_Static_assert(sizeof(struct Y_extra_alignment) == 24, "");
_Static_assert(_Alignof(struct Y_extra_alignment) == 8, "");
_Static_assert(sizeof(struct Y_extra_packed) == 16, "");
_Static_assert(_Alignof(struct Y_extra_packed) == 1, "");
_Static_assert(sizeof(struct Y_extra_required_alignment) == 17, "");
_Static_assert(_Alignof(struct Y_extra_required_alignment) == 1, "");
_Static_assert(sizeof(struct Y_extra_size) == 18, "");
_Static_assert(_Alignof(struct Y_extra_size) == 1, "");
#endif
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.