void CallByPointer(int* p);
void CallByReference(int& r);
int *GetPointer();
int &GetReference();

int FetchFromPointer(int *no_p) {
  return *no_p;
}

int FetchFromReference(int &no_r) {
  return no_r;
}

int *ReturnPointer(int *no_p) {
  return no_p;
}

int &ReturnReference(int &no_r) {
  return no_r;
}

void CallByPointerParamEscape(int *no_p) {
  CallByPointer(no_p);
}

void CallByReferenceParamEscape(int &no_r) {
  CallByReference(no_r);
}

int *MaybeReturn(int *no_p, int *no_q, bool no_b) {
  if (no_b) {
    return no_p;
  } else {
    return no_q;
  }
}

int &EscapeAndReturn(int &no_r) {
  CallByReference(no_r);
  return no_r;
}

struct Point {
    float x;
    float y;
    float z;
};

struct Base {
    float b;
};

struct ReusedBase {
    float rb;
};

struct Intermediate1 : Base, ReusedBase {
    float i1;
};

struct Intermediate2 : ReusedBase {
    float i2;
};

struct Derived : Intermediate1, Intermediate2 {
    float d;
};

class C;

void CEscapes(C *no_c);

class C {
public:
  void ThisEscapes() {
    CEscapes(this);
  }

  C *ThisReturned() {
    return this;
  }

  virtual C *Overridden() {
    CEscapes(this);
    return nullptr;
  }
};

class OverrideReturns : C {
public:
  virtual C *Overridden() {
    return this;
  }
};

class OverrideNone : C {
public:
  virtual C *Overridden() {
    return nullptr;
  }
};

void Escape()
{
    int no_result;
    int no_;

    no_ = 1;
    no_ = no_;
    no_result = no_;
    no_result = *&no_;
//    no_result = (int&)no_;  Restore when we have correct IR types for glvalues
    no_;
    &no_;
    no_result = *((&no_) + 0);
    no_result = *((&no_) - 0);
    no_result = *(0 + &no_);
    if (&no_) {
    }
    while (&no_) {
    }
    do {
    } while (&no_);
    for(&no_; &no_; &no_) {
    }

    if (&no_ == nullptr) {
    }
    while (&no_ != nullptr) {
    }

    int no_Array[10];
    no_Array;
    (int*)no_Array;
    no_Array[5];
    5[no_Array];
    no_result = no_Array[5];
    no_result = 5[no_Array];

    Point no_Point = { 1, 2, 3 };
    float no_x = no_Point.x;
    no_Point.y = no_x;
    float no_y = (&no_Point)->y;
    (&no_Point)->y = no_y;
    float no_z = *(&no_Point.z);
    *(&no_Point.z) = no_z;

    Derived no_Derived;
    no_Derived.b = 0;
    float no_b = no_Derived.b;
    no_Derived.i2 = 1;
    float no_i2 = no_Derived.i2;

    int no_ssa_addrOf;
    int* no_p = &no_ssa_addrOf;

    int no_ssa_refTo;
    int& no_r = no_ssa_refTo;

    int no_ssa_refToArrayElement[10];
    int& no_rae = no_ssa_refToArrayElement[5];

    int no_ssa_refToArray[10];
    int (&no_ra)[10] = no_ssa_refToArray;

    int passByPtr;
    CallByPointer(&passByPtr);

    int passByRef;
    CallByReference(passByRef);

    int no_ssa_passByPtr;
    FetchFromPointer(&no_ssa_passByPtr);

    int no_ssa_passByRef;
    FetchFromReference(no_ssa_passByRef);

    int no_ssa_passByPtr_ret;
    FetchFromPointer(&no_ssa_passByPtr_ret);

    int no_ssa_passByRef_ret;
    FetchFromReference(no_ssa_passByRef_ret);

    int passByPtr2;
    CallByPointerParamEscape(&passByPtr2);

    int passByRef2;
    CallByReferenceParamEscape(passByRef2);

    int passByPtr3;
    CallByPointerParamEscape(ReturnPointer(&passByPtr3));

    int passByRef3;
    CallByReferenceParamEscape(ReturnReference(passByRef3));

    int no_ssa_passByPtr4;
    int no_ssa_passByPtr5;
    bool no_b2 = false;
    MaybeReturn(&no_ssa_passByPtr4, &no_ssa_passByPtr5, no_b2);

    int passByRef6;
    EscapeAndReturn(passByRef6);

    int no_ssa_passByRef7;
    ReturnReference(no_ssa_passByRef7);

    C no_ssa_c;

    no_ssa_c.ThisReturned();

    C c;

    c.ThisEscapes();

    C c2;

    CEscapes(&c2);

    C c3;

    c3.ThisReturned()->ThisEscapes();

    C c4;

    CEscapes(c4.ThisReturned());

    C c5;

    c5.Overridden();

    OverrideReturns or1;
    or1.Overridden();

    OverrideReturns or2;
    CEscapes(or2.Overridden());

    OverrideNone on1;
    on1.Overridden();

    OverrideNone on2;
    CEscapes(on2.Overridden());

    int condEscape1, condEscape2;

    int *no_condTemp;
    if(GetPointer()) {
	no_condTemp = &condEscape1;
    } else {
        no_condTemp = &condEscape2;
    }
    CallByPointer(no_condTemp);
}