char c_i = 1;

char c_c = 'A';

signed char sc_i = -1;

signed char sc_c = 'A';

unsigned char uc_i = 5;

unsigned char uc_c = 'A';

short s = 5;

unsigned short us = 5;

int i = 5;

unsigned int ui = 5;

long l = 5;

unsigned long ul = 5;

long long ll_i = 5;

long long ll_ll = 5LL;

unsigned long long ull_i = 5;

unsigned long long ull_ull = 5ULL;

bool b_t = true;

bool b_f = false;

wchar_t wc_i = 5;

wchar_t wc_c = L'A';

char16_t c16 = u'A';

char32_t c32 = U'A';

float f_i = 1;

float f_f = 1.0f;

float f_d = 1.0;

double d_i = 1;

double d_f = 1.0f;

double d_d = 1.0;

int x = 5 + 12;

short y = 7;

y = x + y;

x = x * y;

int z;

z = x + y;

z = x - y;

z = x * y;

z = x / y;

z = x % y;

z = x & y;

z = x | y;

z = x ^ y;

z = x << y;

z = x >> y;

z = x;

z += x;

z -= x;

z *= x;

z /= x;

z %= x;

z &= x;

z |= x;

z ^= x;

z <<= x;

z >>= x;

z = +x;

z = -x;

z = ~x;

z = !x;

bool b;

b = x == y;

b = x != y;

b = x < y;

b = x > y;

b = x <= y;

b = x >= y;

int y;

y = ++x;

y = --x;

y = x++;

y = x--;

int* p;

p = &(++x);

p = &(--x);

double z;

z = x + y;

z = x - y;

z = x * y;

z = x / y;

z = x;

z += x;

z -= x;

z *= x;

z /= x;

z = +x;

z = -x;

bool b;

b = x == y;

b = x != y;

b = x < y;

b = x > y;

b = x <= y;

b = x >= y;

float y;

y = ++x;

y = --x;

y = x++;

y = x--;

int* q;

bool b;

q = p + i;

q = i + p;

q = p - i;

i = p - q;

q = p;

q += i;

q -= i;

b = p;

b = !p;

int x;

x = p[i];

x = i[p];

p[i] = x;

i[p] = x;

int a[10];

x = a[i];

x = i[a];

a[i] = x;

i[a] = x;

char c = "Foo"[i];

wchar_t* pwc = L"Bar";

wchar_t wc = pwc[i];

bool b;

b = p == q;

b = p != q;

b = p < q;

b = p > q;

b = p <= q;

b = p >= q;

int* q;

q = ++p;

q = --p;

q = p++;

q = p--;

// No conversion necessary

int x = 5;

x += 7;

// Left side is converted to 'int'

short y = 5;

y += x;

// Technically the left side is promoted to int, but we don't model that

y <<= 1;

// Left side is converted to 'float'

long z = 7;

z += 2.0f;

if (b) {

}

if (b) {

x = y;

}

if (x < 7)

x = 2;

else

x = 7;

while (n > 0) {

n -= 1;

}

do {

n -= 1;

} while (n > 0);

int j;

for (;;) {

;

}

for (int i = 0;;) {

;

}

int i = 0;

for (; i < 10;) {

;

}

int i = 0;

for (;; i += 1) {

;

}

for (int i = 0; i < 10;) {

;

}

for (int i = 0;; i += 1) {

;

}

int i = 0;

for (; i < 10; i += 1) {

;

}

for (int i = 0; i < 10; i += 1) {

;

}

for (int i = 0; i < 10; i += 1) {

if (i == 5) {

break;

}

}

for (int i = 0; i < 10; i += 1) {

if (i == 5) {

continue;

}

}

for (int i = 0; i < 10;) {

if (i == 5) {

continue;

}

}

while (n > 0) {

if (n == 1)

break;

n -= 1;

}

do {

if (n == 1) {

continue;

}

n -= 1;

} while (n > 0);

int y;

switch (x) {

y = 1234;

case -1:

y = -1;

break;

case 1:

case 2:

y = 1;

break;

case 3:

y = 3;

case 4:

y = 4;

break;

default:

y = 0;

break;

y = 5678;

}

Point pt;

pt.x = 5;

pt.y = pt.x;

int* p = &pt.y;

int x;

if (a || b) {

x = 7;

}

if (a || b) {

x = 1;

}

else {

x = 5;

}

int x;

if (a && b) {

x = 7;

}

if (a && b) {

x = 1;

}

else {

x = 5;

}

int x;

if (!a) {

x = 1;

}

if (!(a && b)) {

x = 2;

}

else {

x = 3;

}

bool x;

x = a && b;

x = a || b;

x = !(a || b);

int x;

int y;

(a ? x : y) = 5;

int* p = nullptr;

int* q = 0;

p = nullptr;

q = 0;

Point pt1 = { x, f };

Point pt2 = { x };

Point pt3 = {};

int x1 = { 1 };

int x2 = {};

Rect r1 = {};

Rect r2 = { { x, f } };

Rect r3 = { { x, f }, { x, f } };

Rect r4 = { { x }, { x } };

int a1[3] = {};

int a2[3] = { x, f, 0 };

int a3[3] = { x };

if (x < y) {

return;

}

y = x;

if (x < y) {

return x;

}

return x + y;

switch (e) {

case E_0:

return 0;

case E_1:

return 1;

default:

return -1;

}

char a_pad[32] = "";

char a_nopad[4] = "foo";

char a_infer[] = "blah";

char b[2];

char c[2] = {};

char d[2] = { 0 };

char e[2] = { 0, 1 };

char f[3] = { 0 };

int (*pfn)(int) = FuncPtrTarget;

pfn = &FuncPtrTarget;

pfn = *FuncPtrTarget;

pfn = ***&FuncPtrTarget;

String();

String(const String&);

String(String&&);

String(const char*);

~String();

String& operator=(const String&);

String& operator=(String&&);

const char* c_str() const;

char pop_back();

const char* p;

String s1;

String s2("hello");

String s3 = ReturnObject();

String s4 = String("test");

r.c_str();

p->c_str();

s.c_str();

static int StaticMemberFunction(int x) {

return x;

}

int InstanceMemberFunction(int x) {

return x;

}

virtual int VirtualMemberFunction(int x) {

return x;

}

void FieldAccess() {

this->m_a = 0;

(*this).m_a = 1;

m_a = 2;

int x;

x = this->m_a;

x = (*this).m_a;

x = m_a;

}

void MethodCalls() {

this->InstanceMemberFunction(0);

(*this).InstanceMemberFunction(1);

InstanceMemberFunction(2);

}

C() :

m_a(1),

m_c(3),

m_e{},

m_f("test")

{

}

int m_a;

String m_b;

char m_c;

float m_d;

void* m_e;

String m_f;

int& r = x;

int& r2 = r;

const String& r3 = ReturnReference();

int a[10];

int (&ra)[10] = a;

int x = ra[5];

int(&rfn)(int) = FuncPtrTarget;

int(*pfn)(int) = rfn;

rfn(5);

template<typename U, typename V>

static T Func(U x, V y) {

return T();

}

try {

int x = 5;

if (b) {

throw "string literal";

}

else if (x < 2) {

x = b ? 7 : throw String("String object");

}

x = 7;

}

catch (const char* s) {

throw String(s);

}

catch (const String& e) {

}

catch (...) {

throw;

}

String base_s;

Base() {

}

~Base() {

}

String middle_s;

Middle() {

}

~Middle() {

}

String derived_s;

Derived() {

}

~Derived() {

}

String middlevb1_s;

MiddleVB1() {

}

~MiddleVB1() {

}

String middlevb2_s;

MiddleVB2() {

}

~MiddleVB2() {

}

String derivedvb_s;

DerivedVB() {

}

~DerivedVB() {

}

Base b;

Middle m;

Derived d;

Base* pb = &b;

Middle* pm = &m;

Derived* pd = &d;

b = m;

b = (Base)m;

b = static_cast<Base>(m);

pb = pm;

pb = (Base*)pm;

pb = static_cast<Base*>(pm);

pb = reinterpret_cast<Base*>(pm);

m = (Middle&)b;

m = static_cast<Middle&>(b);

pm = (Middle*)pb;

pm = static_cast<Middle*>(pb);

pm = reinterpret_cast<Middle*>(pb);

b = d;

b = (Base)d;

b = static_cast<Base>(d);

pb = pd;

pb = (Base*)pd;

pb = static_cast<Base*>(pd);

pb = reinterpret_cast<Base*>(pd);

d = (Derived&)b;

d = static_cast<Derived&>(b);

pd = (Derived*)pb;

pd = static_cast<Derived*>(pb);

pd = reinterpret_cast<Derived*>(pb);

MiddleVB1* pmv = nullptr;

DerivedVB* pdv = nullptr;

pb = pmv;

pb = pdv;

PolymorphicBase b;

PolymorphicDerived d;

PolymorphicBase* pb = &b;

PolymorphicDerived* pd = &d;

// These two casts are represented as BaseClassCasts because they can be resolved at compile time.

pb = dynamic_cast<PolymorphicBase*>(pd);

PolymorphicBase& rb = dynamic_cast<PolymorphicBase&>(d);

pd = dynamic_cast<PolymorphicDerived*>(pb);

PolymorphicDerived& rd = dynamic_cast<PolymorphicDerived&>(b);

void* pv = dynamic_cast<void*>(pb);

const void* pcv = dynamic_cast<const void*>(pd);

char a[5];

const char* p = a;

p = "test";

p = &a[0];

p = &"test"[0];

char (&ra)[5] = a;

const char (&rs)[5] = "test";

const char (*pa)[5] = &a;

pa = &"test";

__builtin_va_list args2;

__builtin_va_copy(args2, args);

double d = __builtin_va_arg(args, double);

float f = __builtin_va_arg(args, int);

__builtin_va_end(args2);

__builtin_va_list args;

__builtin_va_start(args, x);

__builtin_va_list args2;

__builtin_va_copy(args2, args);

double d = __builtin_va_arg(args, double);

float f = __builtin_va_arg(args, int);

__builtin_va_end(args);

VAListUsage(x, args2);

__builtin_va_end(args2);

char a[32];

void* operator new(size_t);

void* operator new[](size_t);

void operator delete(void*, size_t);

void operator delete[](void*, size_t);

new int; // No constructor

new(1.0f) int; // Placement new, no constructor

new int(); // Zero-init

new String(); // Constructor

new(1.0f) String("hello"); // Placement new, constructor with args

new Overaligned; // Aligned new

new(1.0f) Overaligned(); // Placement aligned new with zero-init

new int[10]; // Constant size

new int[n]; // No constructor

new(1.0f) int[n]; // Placement new, no constructor

new String[n]; // Constructor

new Overaligned[n]; // Aligned new

new(1.0f) Overaligned[10]; // Aligned placement new

new DefaultCtorWithDefaultParam[n];

new int[n] { 0, 1, 2 };

if (bool b = x < y) {

x = 5;

}

else if (int z = x + y) {

y = 7;

}

else if (int* p = &x) {

*p = 2;

}

while (bool b = x < y) {

}

while (int z = x + y) {

}

while (int* p = &x) {

}