// Copyright Amruth N. Kumar, amruth@computer.org

// Master template
// 
// CAUTION: DO NOT USE SAME ORDINALITY FOR A STRUCTURE AND A CLASS IN THE SAME PROGRAM
//   ALSO: DO NOT USE C0 - RESERVED FOR DEFAULT WRAPPER CLASS
//

// Template                              C++                              Java/C#
// -----------------------------------------------------------------------------------------------
// <C1><O1>;                      Student amruth;                      Student amruth;
//                                Declaration+Allocation               Declaration
//                                (Parameters)                         (Parameters, null pointer problems)
// 
// <C1><O1> = <F1.0.0>();         Student amruth;                      Student amruth = new Student();
//                                Declaration+Allocation               Declaration+Allocation
//                                (Objects in clients)                 (Objects in clients)                    
// 
// <C1><O1> = <F2.0.0>();                                              Student amruth = new GradStudent();
//                                                                     Declaration+Allocation
// 
// <C1*><O1>;                     Student * amruth;
//                                Declaration
// 
// <C1*><O1> = <F1.0.0>();        Student * amruth = new Student();
//                                Declaration+Allocation
// 
// <C1*><O1> = <F2.0.0>();        Student * amruth = new GradStudent();
//                                Declaration+Allocation
// 

// Note: <F1.2.x> means <C1>'s <V2>'s selector (x=0) or mutator (x=1)
//       <F1.0.x> means <C1>'s constructor (x=0) or destructor (x=1)
//       Proposed: <F1.*.2> means <C1>'s <F2> that is neither a selector nor a mutator - 
//            notation that can be used to have derived class function call base class function of same name
//            instead of using <C*> or <*1> notation..

// To call base class <C1>'s function from derived class <C2>:
// Constructor:
// <T0><F2.0.0>(){ <F1.0.0>(); }
// Selector/Mutator:
// Note: <C2> does not have its own <V1>, it inherits it and should be treated as such
// <T1><F2.1.0>(){ return <F1.1.0>(); } 
// <T0><F2.1.1>( <T1><V2> ){ <F1.1.1>( <V2> ); }
// as opposed to calling itself recursively:
// <T0><F2.1.1>( <T1><V2> ){ if( <V2> > 0 ) <F2.1.1>( <V2> - 1 ); }
// So, no need for <C*> or <*1>
// Unless base class and derived class have same function which is neither a selector nor mutator?
// May be use the notation <F1.*.2>, for <C1>'s non-data-member-specific <F2>?

// In the following, (B) stands for behavior/output, (D) for debug
// ---------------------------------------------------------------------------------
// // VARIABLES AND FUNCTIONS OF AN OBJECT
// 

// // Accessing public (B) data member by client - 100
// Object.Variable.Public.By Client

// // Accessing protected (D) data member by client - 125
// // Object.Variable.Protected.By Client
// Object.Variable.Protected.Client code does not have access to protected data member of the object

// // Accessing private (D) data member by client - 150
// // Object.Variable.Private.By Client
// Object.Variable.Private.Client code does not have access to private data member of the object
// 



// // All functions public
// // Accessing public (B) data member by dynamic member function - 200
// Object.Variable.Public.By Object Function

// // Accessing protected (B) data member by dynamic member function - 225
// Object.Variable.Protected.By Object Function

// // Accessing private (B) data member by dynamic member function - 250
// Object.Variable.Private.By Object Function
// 

// // Accessing dynamic public data member with respect to the class - 275
// OOP.Object.Variable.The variable is not a static member of the class, and cannot be accessed with respect to the class
// 



// // All public member functions
// // Accessing public (B) member function by client
// // Object.Function.Public.By Client - Further expanded below

// // Accessing protected (D) member function by client - 300
// // Object.Function.Protected.By Client
// Object.Function.Protected.Client code does not have access to protected member function of the object

// // Accessing private (D) member function by client - 325
// // Object.Function.Private.By Client
// Object.Function.Private.Client code does not have access to private member function of the object
// 


// TO DO?
// Accessing dynamic public function with respect to the class - 350?
// OOP.Object.Function.The function is not a static member of the class, and cannot be accessed with respect to the class


// // Execution of constructor code (B) wrt object -  400
// Object.Constructor.By Client

// // Execution of constructor with one or more parameters - 425
// Object.Initialization.Basic object

// TO DO - RENAME
// // Execution of constructor with incorrect number of parameters - 450
// Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition

// TO DO - RENAME
// // Execution of constructor with incorrect data types for parameters - 475
// Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition




// // Execution of selectors (B) wrt object - 500
// Object.Selector.By Client

// TO DO - RENAME
// Ignore this error - No, Keep
// // Value returned by the selector is ignored by the caller - 525
// Object.Selector.Value returned by the function is ignored by the caller

// TO DO - RENAME
// Error only for C++
// // Selector is called before data member is initialized - 550
// Object.Selector.Referencing variable before initializing its value
// TO DO - WHY IS THIS UNDER SELECTOR? WE ARE NOT USING ANY SELECTORS HERE!




// // Execution of mutators (B) wrt object - 600
// Object.Mutator.By Client

// TO DO - RENAME
// Ignore
// // Value returned by the mutator is ignored by the caller - 625
// Object.Mutator.Value returned by the function is ignored by the caller

// TO DO - RENAME
// Ignore - No, keep?
// // Mutator is called with incorrect number of parameters - 650
// Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition

// TO DO - RENAME
// Ignore
// // Mutator is called with incorrect data type for parameters - 675
// Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition




// Only C++, C#, Not for Java
// // Execution of destructor code (B) wrt object - 700
// Object.Destructor.By Client




// // Assigning an object to class instead of another object - 800
// // Object.Assignment.Aggregate.Assigning to class
// Object.Assignment.Aggregate.Object cannot be assigned to a class
// // Aggregate assignment from one object to another - 825
// Object.Assignment.Aggregate.Assigning object to variable
// // Object passed as parameter to a function where it is accessed - 850
// Object.Parameter.Aggregate.Accessed
// // Object passed as parameter to a function where it is modified - 875
// Object.Parameter.Aggregate.Modified

// // ---------------------------------------------------------------------------------
// // STATIC VARIABLE AND FUNCTION IN A CLASS

// 
// // Accessing dynamic (D) data member by static member function - 300
// // Object.Variable.Public.By Class Function
// OOP.Object.Variable.The variable is not a static member of the class, and cannot be accessed in a static function
// // Accessing protected (D) data member by static member function
// // Object.Variable.Protected.By Class Function
// // Accessing private (D) data member by static member function
// // Object.Variable.Private.By Class Function
// Object.Variable.Private.Class (static) function does not have access to private data member of the object
// 

// // Accessing static public (B) data member by client - 1000
// Class.Variable.Public.Wrt Class
// // Accessing static public (B) data member by client - 1025
// Class.Variable.Public.Wrt Object
// // Accessing static protected (D) data member by client - 1050
// Class.Variable.Protected.By Client
// // Accessing static private (D) data member by client - 1075
// Class.Variable.Private.By Client
// 
// // Accessing static public (B) data member by static member function - 1100
// Class.Variable.Public.By Class Function
// // Accessing static protected (B) data member by static member function - 1125
// Class.Variable.Protected.By Class Function
// // Accessing static private (B) data member by static member function - 1150
// Class.Variable.Private.By Class Function
// 
// // Accessing static public (D) data member by dynamic member function - 1200
// Class.Variable.Public.By Object Function
// // Accessing static protected (D) data member by dynamic member function - 1225
// Class.Variable.Protected.By Object Function
// // Accessing static private (D) data member by dynamic member function - 1250
// Class.Variable.Private.By Object Function
// 
// // Accessing static public (B) member function wrt class name by client - 1300
// Class.Function.Public.Wrt Class
// // Accessing static public (D) member function wrt object by client - 1325
// Class.Function.Public.Wrt Object
// // Accessing static protected (D) member function by client - 1350
// Class.Function.Protected.By Client
// // Accessing static private (D) member function by client - 1375
// Class.Function.Private.By Client
// 
// // ---------------------------------------------------------------------------------
// // COMPOSITION OF CLASSES
// 
// // Called in Composer function, which is in turn called by client
// // Accessing public (B) data member by composing class - 2000
// Object.Variable.Public.By Composer
// // Accessing protected (D) data member by composing class - 2025
// Object.Variable.Protected.By Composer
// // Accessing private (D) data member by composing class - 2050
// Object.Variable.Private.By Composer
// 
// // Called in Composer function, which is in turn called by client
// // Accessing public (B) member function by composing class 
// // Object.Function.Public.By Composer.Function - Expanded below
// // Accessing protected (D) member function by composing class - 2100
// Object.Function.Protected.By Composer
// // Accessing private (D) member function by composing class - 2125
// Object.Function.Private.By Composer
// 
// // Execution of constructor code (B) by composing class constructor - 2200
// Object.Constructor.By Composer

// // Calling constructor with arguments, some of which are used to initialize composed object - 2225
// Object.Initialization.Composed object

// // Execution of selectors (B) by composing class function - 2250
// Object.Selector.By Composer
// // Execution of mutators (B) by composing class function - 2275
// Object.Mutator.By Composer
// // Execution of destructor code (B) by composing class destructor - 2300
// Object.Destructor.By Composer
// 
// // Accessing public (D) data member wrt composing object by client - 2400
// Object.Variable.Public.Wrt Composer
// // Accessing protected (D) data member wrt composing object by client - 2425
// Object.Variable.Protected.Wrt Composer
// // Accessing private (D) data member wrt composing object by client - 2450
// Object.Variable.Private.Wrt Composer
// 
// // Accessing public (D) member function wrt composing object by client - 2500
// Object.Function.Public.Wrt Composer
// // Accessing protected (D) member function wrt composing object by client - 2525
// Object.Function.Protected.Wrt Composer
// // Accessing private (D) member function wrt composing object by client - 2550
// Object.Function.Private.Wrt Composer
// 

// Following are for chained dot operator, where operands are both member function calls
//   Elsewhere, we see chained dot operators, where one operand is a data member
// // Object is returned by a function, which is then accessed - 2600
// Object.Returned.By Composer  // Calling selector/mutator w.r.t object returned by Composer

// // ---------------------------------------------------------------------------------
// // PUBLIC INHERITANCE
// 
// // Called in inheritor function, which is in turn called by client
// // Accessing public (B) data member by inheriting class - 3000
// Object.Variable.Public.By Inheritor
// // Accessing protected (B) data member by inheriting class - 3025
// Object.Variable.Protected.By Inheritor
// // Accessing private (D) data member by inheriting class - 3050
// Object.Variable.Private.By Inheritor
// 
// // Called in inheritor function, which is in turn called by client
// // Accessing public (B) member function by inheriting class 
// // Object.Function.Public.By Inheritor.Function - Expanded below
// // Accessing protected (B) member function by inheriting class - 3100
// Object.Function.Protected.By Inheritor
// // Accessing private (D) member function by inheriting class - 3125
// Object.Function.Private.By Inheritor
// 
// // Accessing public (B) data member wrt inheriting object by client - 3200
// Object.Variable.Public.Wrt Inheritor
// // Accessing protected (D) data member wrt inheriting object by client - 3225
// Object.Variable.Protected.Wrt Inheritor
// // Accessing private (D) data member wrt inheriting object by client - 3250
// Object.Variable.Private.Wrt Inheritor
// 
// // Accessing public (B) member function wrt inheriting object by client - 3300
// Object.Function.Public.Wrt Inheritor
// // Accessing protected (D) member function wrt inheriting object by client - 3325
// Object.Function.Protected.Wrt Inheritor
// // Accessing private (D) member function wrt inheriting object by client - 3350
// Object.Function.Private.Wrt Inheritor

// // Execution of constructor code (B) when inheriting class's constructor calls it - 3400
// Object.Constructor.Inheritor.Coopted
// // Execution of constructor code (B) when inheriting class's constructor does not call it - 3425
// Object.Constructor.Inheritor.Not Coopted

// // Constructor is called with arguments, some of which are passed to base class - 3450
// Object.Initialization.Inherited object

// // In each problem, call the overridden function wrt BOTH base and derived class object
// // Execution of selectors (B) by inheriting class 
// // Execution of selectors (B) by client wrt inheriting object which overrides it, calls it and behavior is polymorphic - 3500
// Object.Selector.Inheritor.Overridden.Coopted.Polymorphic
// // Execution of selectors (B) by client wrt inheriting object which overrides it, does not call it and behavior is polymorphic - 3525
// Object.Selector.Inheritor.Overridden.Not Coopted.Polymorphic
// // Execution of selectors (B) by client wrt inheriting object which does not override - 3550
// Object.Selector.Inheritor.Not Overridden
// // Execution of selectors (B) by client wrt inheriting object which overrides it, calls it, and behavior is not polymorphic (C++ only) - 3575
// Object.Selector.Inheritor.Overridden.Coopted.NonPolymorphic
// // Execution of selectors (B) by client wrt inheriting object which overrides it, does not call it, and behavior is not polymorphic (C++ only) - 3600
// Object.Selector.Inheritor.Overridden.Not Coopted.NonPolymorphic
// 
// // In each problem, call the overridden function wrt both base and derived class object
// // Execution of mutators (B) by inheriting class 
// // Execution of mutators (B) by client wrt inheriting object which overrides it, calls it and behavior is polymorphic - 3700
// Object.Mutator.Inheritor.Overridden.Coopted.Polymorphic
// // Execution of mutators (B) by client wrt inheriting object which overrides it, does not call it and behavior is polymorphic - 3725
// Object.Mutator.Inheritor.Overridden.Not Coopted.Polymorphic
// // Execution of mutators (B) by client wrt inheriting object which does not override - 3750
// Object.Mutator.Inheritor.Not Overridden
// // Execution of mutators (B) by client wrt inheriting object which overrides it, calls it, and behavior is not polymorphic (C++ only) - 3775
// Object.Mutator.Inheritor.Overridden.Coopted.NonPolymorphic
// // Execution of mutators (B) by client wrt inheriting object which overrides it, does not call it, and behavior is not polymorphic (C++ only) - 3800
// Object.Mutator.Inheritor.Overridden.Not Coopted.NonPolymorphic
//
// // Execution of destructor code (B) by inheriting class's destructor - 3850
// Object.Destructor.By Inheritor
// 
// // Assigning base class object to derived class variable - 3900
// Object.Assignment.Aggregate.Assigning base object to derived variable
// // Assigning derived class object to base class variable - 3925
// Object.Assignment.Aggregate.Assigning derived object to base variable
// // Assigning object of one derived class to variable of another derived class - 3950
// Object.Assignment.Aggregate.Assigning derived object to different derived variable

// ---------------------------------------------------------------------------------------
// INVERSE OF INHERITANCE

// // Called in inheritor function, which is in turn called by client
// // Accessing public (B) data member by ancestral class - 4000
// Object.Variable.Public.By Ancestor
// // Accessing protected (B) data member by ancestral class - 4025
// Object.Variable.Protected.By Ancestor
// // Accessing private (D) data member by ancestral class - 4050
// Object.Variable.Private.By Ancestor
// 
// // Called in inheritor function, which is in turn called by client

// // Accessing public (B) member function by ancestral class - 4100
// Object.Function.Public.By Ancestor
// // Accessing protected (B) member function by ancestral class - 4125
// Object.Function.Protected.By Ancestor
// // Accessing private (D) member function by ancestral class - 4150
// Object.Function.Private.By Ancestor
// 

// // Accessing public (B) data member wrt ancestral object by client - 4200
// Object.Variable.Public.Wrt Ancestor
// // Accessing protected (D) data member wrt ancestral object by client - 4225
// Object.Variable.Protected.Wrt Ancestor
// // Accessing private (D) data member wrt ancestral object by client - 4250
// Object.Variable.Private.Wrt Ancestor
// 

// // Accessing public (B) member function wrt ancestral object by client - 4300
// Object.Function.Public.Wrt Ancestor
// // Accessing protected (D) member function wrt ancestral object by client - 4325
// Object.Function.Protected.Wrt Ancestor
// // Accessing private (D) member function wrt ancestral object by client - 4350
// Object.Function.Private.Wrt Ancestor

// Notation:
// <F1.0.0>:
//    <C1>'s constructor (last digit is 0)
//        In client:
//          <C1><O1> = <F1.0.0>();
//        In composing object's constructor:
//          <O1> = <F1.0.0>(); 
//        In inheriting object's constructor:
//          <F1.0.0>();
//    Note: <T0> is used as return type in the definition so that TemplateParser.isFunctionHeader() 
//    will properly identify constructor as a function
// <F1.0.1>:
//    <C1>'s destructor (last digit is 1)
//    Note: <T0> is used as return type in the definition so that TemplateParser.isFunctionHeader() 
//    will properly identify destructor as a function
// <F1.2.0>: 
//    <C1>'s <V2>'s selector (last digit is 0) (Note: <V2> may be inherited from <C1>'s parent!)
//        In client:
//          << <O1>.<F1.2.0>();
//        In inheriting object's selector (assuming <C1> inherited from <C2>):
//          return <F2.2.0>();
//    Note: Selector's name is not logged in SymbolTable
// <F3.2.1>: 
//    <C3>'s <V2>'s mutator (last digit is 1) (Note: <V2> may be inherited from <C1>'s parent!)
//    Note: Mutator's name is not logged in SymbolTable
// Say <C1> is the parent and <C2> inherits from it 
//   <F2> is defined in <C1> and overridden in <C2>
//   In <C2>.<F2>() definition, <F2>(); would be a recursive call.
//   How do we call <C1>'s <F2>()? Use notation <F1.*.2>, for <C1>'s non-data-member-specific <F2>?


// ---------------------------------------------------------------------------------
// Each problem tests wrt some client code that accesses the data member of member function in question
// In the following, (B) stands for behavior/output, (D) for debug

// =================================================================================
// // VARIABLES AND FUNCTIONS OF AN OBJECT
// ---------------------------------------------------------------------------------
// // Accessing public (B) data member by client - 100
// Object.Variable.Public.By Client

# 100
OOP.Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T1><F2>(){return <V1>;}
   <T0><F1>(<T1><V2>){<V1>=<V2>;}
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#1<=R1<=9;#>;
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 101
OOP.Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1#signedtype#><F2>(){<< <V1>;return <V1> / 10;}
   <T1><V1>;
   <T0><F1>(<T1><V2>){if(<V2> > 0) <V1>= 50; else <V1> = 10;}
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> =  <R1#1<=R1<=9;#>;
  <O1>.<V1> = <V2>;
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 102
OOP.Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1#signedtype#><F2>(){return <V1> / 2;}
   <T0><F1>(<T1><V2>){<< <V2>;<V1>=<V2> * 2;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> =  <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <V2>;
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

// integrated problem - pre
# 103
OOP.Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1#signedtype#><F2>(){return --<V1>;}
   <T1><V1>;
   <T0><F1>(<T1><V2>){<V1> = <V2>; ++<V1>; << <V1>;}
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#1<=R1<=9;#>;
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

// integrated problem - post
# 104
OOP.Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T1><F2>(){<V1> = <V1> / 2; << <V1>; return <V1>;}
   <T0><F1>(<T1><V2>){<V1>=<V2>;<V1> = <V1> * 2;}
protected: 
private:
}
<T0><F0>(){
  <T1><V2> =  <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <V2>;
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member by client - 125
// Object.Variable.Protected.By Client
// Object.Variable.Protected.The variable is protected in the class and cannot be accessed
// Old: Client code does not have access to protected data member of the object

# 125
OOP.Object.Variable.Protected.The variable is protected in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signedtype#><F2>(){return <V1>;}
   <T0><F1>(<T1><V2>){<V1>=<V2>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#0<=R1<=9;#>;
  <T1><V2> = <R1>;
  << <V2> + 1;
}}
>
Type: debug_output
Hardness: 10 

# 126
OOP.Object.Variable.Protected.The variable is protected in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signedtype#><F2>(){<< <V1>;return <V1> - 10;}
   <T0><F1>(<T1><V2>){if(<V2> > 0) <V1>=<V2> + 10; else <V1> = 10;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <T1><V2> = <R1#10<=R1<=19;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <V2>;
  << <V2> * 10;
}}
>
Type: debug_output
Hardness: 10 

# 127
OOP.Object.Variable.Protected.The variable is protected in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signedtype#><F2>(){return <V1> / 2;}
   <T0><F1>(<T1><V2>){<V1>=<V2> * 2;<< <V1>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <R1#20<=R1<=29;#>;
  <O1>.<V1> = <V2>;
  << <V2> / 2;
}}
>
Type: debug_output
Hardness: 10 

// integrated problem - pre
# 128
OOP.Object.Variable.Protected.The variable is protected in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signedtype#><F2>(){return --<V1>;}
   <T0><F1>(<T1><V2>){<V1> = <V2>; ++<V1>; << <V2>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <R1#30<=R1<=39;#>;
  <O1>.<V1> = <R1>;
  << <V2> + 10;
}}
>
Type: debug_output
Hardness: 10 

// integrated problem - post
# 129
OOP.Object.Variable.Protected.The variable is protected in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signedtype#><F2>(){<< <V1>; <V1> = <V1> / 2; << <V1>; return <V1>;}
   <T0><F1>(<T1><V2>){<V1>=<V2>;<V1> = <V1> * 2;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <T1><V2> = <R1#40<=R1<=49;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <V2>;
  << <V2> * 2;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member by client - 150
// Object.Variable.Private.By Client
// Object.Variable.Private.The variable is private in the class and cannot be accessed
// Old: Client code does not have access to private data member of the object

# 150
OOP.Object.Variable.Private.The variable is private in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signedtype#><F2>(){return <V1>;}
   <T0><F1>(<T1><V2>){<V1>=<V2>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#40<=R1<=49;#>;
  <T1><V2> = <R1>;
  << <V2> + <V2>;
}}
>
Type: debug_output
Hardness: 10 

# 151
OOP.Object.Variable.Private.The variable is private in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signedtype#><F2>(){<< <V1> * 2;return <V1> - 10;}
   <T0><F1>(<T1><V2>){if(<V2> > 0) <V1>=<V2> * 10; else <V1> = 0; << <V1>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <T1><V2> = <R1#30<=R1<=39;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <V2>;
  << <V2> * <V2>;
}}
>
Type: debug_output
Hardness: 10 

# 152
OOP.Object.Variable.Private.The variable is private in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signedtype#><F2>(){return <V1> / 2;}
   <T0><F1>(<T1><V2>){<V1>=<V2> * 10; << <V1>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <R1#20<=R1<=29;#>;
  <O1>.<V1> = <V2>;
  << <V2> / 10;
}}
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 153
OOP.Object.Variable.Private.The variable is private in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signedtype#><F2>(){--<V1>; << <V1>; return <V1>;}
   <T0><F1>(<T1><V2>){<V1> = <V2>; ++<V1>; << <V1>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <R1#10<=R1<=19;#>;
  <O1>.<V1> = <R1>;
  << <V2> % 2;
}}
>
Type: debug_output
Hardness: 10 

// integrated - post
# 154
OOP.Object.Variable.Private.The variable is private in the class and cannot be accessed
>
{<C1>{
public:
   <T1#signedtype#><F2>(){<V1> = <V1> / 2; << <V1>; return <V1>;}
   <T0><F1>(<T1><V2>){<V1>=<V2>;<V1> = <V1> * 2; << <V1>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <T1><V2> = <R1#50<=R1<=59;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <V2>;
  << <V2> / 10 + <V2> % 10;
}}
>
Type: debug_output
Hardness: 10 

// =================================================================================
// // All functions public
// ---------------------------------------------------------------------------------
// // Accessing public (B) data member by dynamic member function - 200
// Object.Variable.Public.By Object Function

# 200
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F2>(){<V1> = <R1#1<=R1<=9;#>; << <V1>;}
   <T0><F1>(<T1#signedtype#><V2>){if(<V2> >= 0){ <V1>=<V2>;} else {<V1> = <V2> * -1;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>();
}}
>
Type: debug_output
Hardness: 10 

# 201
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F2>(){<V1> = <R1#1<=R1<=9;#>; return <V1>;}
   <T0><F1>(<T1><V2>){if(<V2> >= <R2#4<=R2<=6;#>){ <V1>=<V2> - <R2>;} else {<V1> = <V2> + <R2>;} << <V1>; << <V2>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F2>();
}}
>
Type: debug_output
Hardness: 10 

# 202
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R2#10<=R2<=19;#>; if( <V1> % 2 != 0 ){-- <V1>;} << <V1>;}
   <T0><F2>(<T1#signedtype#><V2>){<V1> = <V2>; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>(<R1#1<=R1<=9;#>);
}}
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 203
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R2#10<=R2<=19;#>; if( <V1> % 2 != 0 ){-- <V1>;} << <V1>;}
   <T1#signedtype#><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F2>(<R1#1<=R1<=9;#>);
}}
>
Type: debug_output
Hardness: 10 

# 204
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V4>){<V1> = <V4>; ++ <V1>; -- <V4>; << <V1>; << <V4>;}
   <T0><F2>(<T1><V2>){<V1> = <V2>; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V3>=<R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

// integrated - post
# 205
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V4>){<V1> = <V4>; << <V1> * 2; << <V4> / 2; << <V1> - <V4>;}
   <T1><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3>=<R1#1<=R1<=9;#>;
  << <O1>.<F2>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (B) data member by dynamic member function - 225
// Object.Variable.Protected.By Object Function

# 225
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F2>(){<V1> = <R1#1<=R1<=9;#>; << <V1>;}
   <T0><F1>(<T1#signedtype#><V2>){<V1>=<V2>; << <V1>; <V1> *= 5; << <V1>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>();
}}
>
Type: debug_output
Hardness: 10 

# 226
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F2>(){>> <V1>; << <V1>;}
   <T0><F1>(<T1#signedtype#><V2>){<T1><V3>;for( <V3> = 0; <V3> < <V2>; <V3>++ )<< <V3>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

//   <T0><F1>(<T1><V2>){<< <V2>; if(<V2> >= <R2#4<=R2<=6;#>){ <V1>=<V2> / <R2>;} else {<V1> = <V2> * <R2>;} << <V1>; }

// integrated - pre
# 227
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R2#10<=R2<=19;#>; << <V1>; if( <V1> % 2 != 0 ){<V1> /= 2;} << <V1>;}
   <T0><F2>(<T1#signedtype#><V2>){<V1> = <V2>; << <V1>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>(<R1#1<=R1<=9;#>);
}}
>
Type: debug_output
Hardness: 10 

// integrated - post
# 228
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V4>){do{<< <V4>; <V4> = <V4> - 1; }while( <V4> > 0 );}
   <T0><F2>(<T1><V2>){<V1> = <V2>; << <V1>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <T1><V3>;
  <C1><O1> = <F1.0.0>();
  >> <V3>;
  <O1>.<F2>(<V3>);
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 229
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V4>){for( <V1> = 0; <V1> <= <V4>; ++<V1>){ << <V1>; } << <V4>;}
   <T0><F2>(<T1><V2>){<V1> = <V2>; << <V1>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <T1><V3>=<R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

# 230
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V4>){while( <V4> > 0 ){ <V4> = <V4> / 2; << <V4>;  }}
   <T1><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3>;
  >> <V3>;
  << <O1>.<F2>(<V3>);
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

//   <T0><F1>(<T1#signedtype#><V4>){<V1> = <V4>; do{ << <V1> * 2; <V1> -= 3; }while( <V1> > 0); << <V4>;}

// ---------------------------------------------------------------------------------
// // Accessing private (B) data member by dynamic member function - 250
// Object.Variable.Private.By Object Function

# 250
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T0><F2>(){>> <V1>; << <V1>;}
   <T0><F1>(<T1#signedtype#><V2>){<T1><V3>;for( <V3> = 0; <V3> < <V2>; <V3>++ )<< <V3>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

//   <T0><F1>(<T1#signedtype#><V2>){<< <V2>; <V2> = <V2> * <V2>; <V1> = <V2> / 2; << <V1>;}

# 251
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F2>(){<V1> = <R1#1<=R1<=9;#>; return <V1>;}
   <T0><F1>(<T1><V2>){<V1> = 0; while( <V1> > <V2> ){ ++<V1>; --<V2>; << <V1>; << <V2>; }}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F2>();
}}
>
Type: debug_output
Hardness: 10 

# 252
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R2#2<=R2<=9;#>; << <V1>; while( <V1> < <R3#100<=R3<=199;#> ){ <V1> = <V1> * <V1>; << <V1>; } }
   <T0><F2>(<T1#signedtype#><V2>){<V1> = <V2>; << <V1>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <T1><V3>;
  <C1><O1> = <F1.0.0>();
  >> <V3>;
  <O1>.<F2>(<V3>);
}}
>
Input: "<R1#1<=R1<=4;#>\n<R4#5<=R4<=9;#>\n<R5#1<=R5<=9;#>"
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 253
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V4>){<V1> = <V4>; << <V1>; <V1> *= 2; << <V1>; <V1> += 3; << <V1>; <V1> /= 5; << <V1>;}
   <T1><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3>;
  >> <V3>;
  << <O1>.<F2>(<V3>);
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// integrated - post
# 254
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R2#210<=R2<=299;#>; <V1> %= 7; << <V1>; <V1> %= 5; << <V1>; <V1> %= 3; << <V1>; <V1> %= 2; << <V1>; }
   <T1#signedtype#><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F2>(<R1#1<=R1<=9;#>);
}}
>
Type: debug_output
Hardness: 10 

# 255
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V4>){<V1> = 0; while( <V4> > 0 ){ <V1> += <R1#1<=R1<=9;#>; <V4>--; } << <V1>;}
   <T1><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3>=<R1>;
  << <O1>.<F2>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing dynamic data member with respect to the class - 275

# 275
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T1><V1>;
protected: 
   <T0><F2>(){<V1> = <R1#1<=R1<=9;#>; << <V1>;}
   <T0><F1>(<T1#signedtype#><V2>){if(<V2> >= 0){ <V1>=<V2>;} else {<V1> = <V2> * -1;} }
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<V1> = <R1>;
  << <R1>;
}}
>
Type: debug_output
Hardness: 10 

# 276
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T0><F2>(){<V1> = <R1#1<=R1<=9;#>;}
   <T1><V1>;
protected: 
   <T0><F1>(<T1#signedtype#><V2>){if(<V2> >= <R2#4<=R2<=6;#>){ <V1>=<V2> + <R2>;} else {<V1> = <V2> * <R2>;} << <V1>; }
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>();
  << <C1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 277
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T0><F2>(<T1#signedtype#><V2>){<V1> = <V2>; << <V1>;}
   <T1><V1>;
protected: 
private:
   <T0><F1>(){<V1> = <R2#10<=R2<=19;#>; if( <V1> % <R3#2<=R3<=9;#> != 0 ){<V1> -= <R3>;} << <V1>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>(<R1#1<=R1<=9;#>);
  << <C1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 278
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T1#signedtype#><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
   <T1><V1>;
protected: 
   <T0><F1>(){<V1> = <R2#10<=R2<=19;#>; << <V1>; <V1> /= <R3#5<=R3<=9;#>; << <V1>;}
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F2>(<R1#1<=R1<=9;#>);
  <C1>.<V1> = <R1> + 1;
}}
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 279
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T0><F2>(<T1><V2>){<V1> = <V2>; << <V1>;}
   <T1><V1>;
protected: 
private:
   <T0><F1>(<T1#signedtype#><V4>){<V1> = <V4>; <V1> += <R1>; << <V1>; <V4> -= <R1>; << <V4>;}
}
<T0><F0>(){
  <T1><V3>=<R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>(<V3>);
  << <C1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

// integrated - post
# 280
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T1><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
   <T1><V1>;
protected: 
   <T0><F1>(<T1#signedtype#><V4>){<V1> = <V4>; << <V1> + 2; << <V4> % 2; << <V1> * <V4>;}
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3>=<R1#1<=R1<=9;#>;
  << <O1>.<F2>(<V3>);
  << <C1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) member function by client - 300
// Object.Function.Protected.By Client
// Object.Function.Protected.The function is protected in the class and cannot be called
// Old: Client code does not have access to protected member function of the object

# 300
OOP.Object.Function.Protected.The function is protected in the class and cannot be called
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T0><F2>(){<V1> = <R1#1<=R1<=9;#>; << <V1>;}
protected: 
   <T0><F1>(<T1><V2>){<V1>=<V2>; << <V1>; <V1> *= <V1>; << <V1>;}
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>(<R1>);
}}
>
Type: debug_output
Hardness: 10 

# 301
OOP.Object.Function.Protected.The function is protected in the class and cannot be called
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T1><F2>(){<V1> = <R1#1<=R1<=9;#>; return <V1>;}
protected: 
   <T0><F1>(<T1><V2>){<V1> = <R2#4<=R2<=6;#>; if(<V2> >= <V1>){ <V1> = <V2> / <V1>;} else {<V1> = <V1> / <V2>;} << <V1>; }
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1>(<R1>);
}}
>
Type: debug_output
Hardness: 10 

# 302
OOP.Object.Function.Protected.The function is protected in the class and cannot be called
>
{<C1>{
public:
   <T0><F2>(<T1#signedtype#><V2>){<V1> = <V2>; << <V1>;}
   <T1><V1>;
protected: 
   <T0><F1>(){<V1> = <R2#10<=R2<=19;#>; << <V1>; switch( <V1> % 3 ) { case 0: << <V1>; break; case 1: << <V1> - 1; break; default: << <V1> - 2; } }
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 303
OOP.Object.Function.Protected.The function is protected in the class and cannot be called
>
{<C1>{
public:
   <T1#signedtype#><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
   <T1><V1>;
protected: 
   <T0><F1>(){<V1> = <R2#1<=R2<=9;#>; while( <V1> > 0 ){<< <V1> * 2; <V1> -= 2;} }
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

# 304
OOP.Object.Function.Protected.The function is protected in the class and cannot be called
>
{<C1>{
public:
   <T0><F2>(<T1#signedtype#><V2>){<V1> = <V2>; << <V1>;}
   <T1><V1>;
protected: 
   <T0><F1>(<T1><V4>){for( <V1> = 0; <V1> <= <V4>; <V1> += 2){ << <V1> / 2; } << <V4> / 2 + 1;}
private:
}
<T0><F0>(){
  <T1><V3>=<R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

// integrated - post
# 305
OOP.Object.Function.Protected.The function is protected in the class and cannot be called
>
{<C1>{
public:
   <T1><F2>(<T1#signedtype#><V2>){<V1> = <V2>; return <V1>;}
   <T1><V1>;
protected: 
   <T0><F1>(<T1><V4>){<V1> = <V4>; do{ << <V1> * 3; <V1> -= 3; }while( <V1> > 0); << <V4> / 3;}
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3>=<R1#1<=R1<=9;#>;
  << <O1>.<F1>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function by client - 425
// Object.Function.Private.By Client
// Object.Function.Private.The function is private in the class and cannot be called
// Old: Client code does not have access to private member function of the object

# 325
OOP.Object.Function.Private.The function is private in the class and cannot be called
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T0><F1>(<T1><V2>){<< <V2>; <F2>(); }
protected: 
private:
   <T0><F2>(){<V1> = <R1#1<=R1<=9;#>; <V1> += <R1>; << <V1>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>();
}}
>
Type: debug_output
Hardness: 10 

# 326
OOP.Object.Function.Private.The function is private in the class and cannot be called
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V2>){ << <V2>; if( <V2> > 0 ){ <F1>( <V2> - 1  ); }}
   <T1><V1>;
protected: 
private:
   <T1><F2>(){<V1> = <R1#1<=R1<=9;#>; <V1> -= <R1>; return <V1>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F2>();
}}
>
Type: debug_output
Hardness: 10 

# 327
OOP.Object.Function.Private.The function is private in the class and cannot be called
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T0><F1>(){<V1> = <R2#2<=R2<=9;#>; << <V1>; <F2>( <V1> + 1 ); }
protected: 
private:
   <T0><F2>(<T1><V2>){<V1> = <V2>; <V1> *= <V2>; << <V1>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>(<R1#1<=R1<=9;#>);
}}
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 328
OOP.Object.Function.Private.The function is private in the class and cannot be called
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R2#210<=R2<=299;#>; << <F2>( <V1> * 2 ); }
   <T1#signedtype#><V1>;
protected: 
private:
   <T1><F2>(<T1><V2>){<V1> = <V2>; <V1> %= 2; return <V1>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F2>(<R1#1<=R1<=9;#>);
}}
>
Type: debug_output
Hardness: 10 

# 329
OOP.Object.Function.Private.The function is private in the class and cannot be called
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T0><F1>(<T1><V4>){<F2>(<V4>); <F2>(<V4> + 1); }
protected: 
private:
   <T0><F2>(<T1><V2>){<V1> = <V2>; <V1> /= 2; << <V1>;}
}
<T0><F0>(){
  <T1><V3>=<R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

// integrated - post
# 330
OOP.Object.Function.Private.The function is private in the class and cannot be called
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V4>){<< <F2>( <V4> ) * <F2>( <V4> + 1 ); }
   <T1><V1>;
protected: 
private:
   <T1><F2>(<T1><V2>){<V1> = <V2>; <V2>++; return <V1>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3>=<R1>;
  << <O1>.<F2>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------

// OOP.Object.Function.The function is not a static member of the class, and cannot be accessed with respect to the class

# 350
OOP.Object.Function.The function is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V2>){if(<V2> >= 0){ <V1>=<V2>;} else {<V1> = <V2> * -1;} }
protected: 
   <T0><F2>(){<V1> = <R1#21<=R1<=29;#>; << <V1>;}
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>(<R1>);
}}
>
Type: debug_output
Hardness: 10 

# 351
OOP.Object.Function.The function is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V2>){if(<V2> >= <R2#4<=R2<=6;#>){ <V1> = <V2> / <R2>;} else {<V1> = <V2> % <R2>;} << <V1>; }
protected: 
   <T1><F2>(){<V1> = <R1#31<=R1<=39;#>; return <V1>;}
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <C1>.<F1>(<R1>);
}}
>
Type: debug_output
Hardness: 10 

# 352
OOP.Object.Function.The function is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R2#40<=R2<=49;#>; if( <V1> % 2 != 0 ){<V1> /= 2 + 1;} << <V1>;}
protected: 
   <T0><F2>(<T1#signedtype#><V2>){<V1> = <V2>; << <V1>;}
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

# 353
OOP.Object.Function.The function is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R2#50<=R2<=59;#>; if( <V1> % 2 != 0 ){++<V1>;} << <V1>;}
protected: 
   <T1#signedtype#><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <C1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 354
OOP.Object.Function.The function is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V4>){<V1> = <V4>; <V1> += <R2#5<=R2<=9;#>; <V4> -= <R2>; << <V1>; << <V4>;}
protected: 
   <T0><F2>(<T1><V2>){<V1> = <V2>; << <V1>;}
private:
   <T1><V1>;
}
<T0><F0>(){
  <T1><V3>=<R1#61<=R1<=69;#>;
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

// integrated - post
# 355
OOP.Object.Function.The function is not a static member of the class and cannot be accessed with respect to the class
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V4>){<V1> = <V4>; << <V1> * <R2#5<=R2<=9;#>; << <V4> / <R2>; << <V1> - <V4>;}
protected: 
   <T1><F2>(<T1><V2>){<V1> = <V2>; return <V1>;}
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3>=<R1#71<=R1<=79;#>;
  << <C1>.<F1>(<V3>);
}}
>
Type: debug_output
Hardness: 10 

// =================================================================================

// // All public member functions
// ---------------------------------------------------------------------------------
// // Execution of constructor code (B) wrt object - 400
// Object.Constructor.By Client
//  This learning objective is only about constructor code being executed, not data members being initialized

# 400
OOP.Object.Constructor.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<T1#signedtype#><V2> = <R1#1<=R1<=9;#>;<< <V2>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3> = <R2#R2 = R1 * 10;#>;
  << <V3>;
}}
>
Type: debug_output
Hardness: 10 

# 401
OOP.Object.Constructor.By Client
?
Object.Variable.Public.By Object Function
>
[<R1#1<=R1<=4;#>]
{<C1>{
public:
   <T0><F1.0.0>(){<T1#signedtype#><V2>; >> <V2>; << <V2>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <T1><V3> = <R5#R5 = R1 + 10;#>;
  <C1><O1> = <F1.0.0>();
  << <V3>;
}}
>
Input: "<R1>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// Integrated problem - pre
# 402
OOP.Object.Constructor.By Client
?
Object.Variable.Public.By Object Function
>
[<R1#1<=R1<=4;#>]
{<C1>{
public:
   <T0><F1.0.0>(){<T1#signedtype#><V2> = <R6#R6 = R1 + 1;#>; << <V2>; >> <V2>; << <V2>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <T1><V3> = <R5#R5 = R1 * 2;#>;
  <C1><O1> = <F1.0.0>();
}}
>
Input: "<R1>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// Integrated problem - post
# 403
OOP.Object.Constructor.By Client
?
Object.Variable.Public.By Object Function
>
[<R1#1<=R1<=4;#>,<R2#5<=R2<=9;#>]
{<C1>{
public:
   <T0><F1.0.0>(){<T1#signedtype#><V2>; >> <V2>; << <V2>; <V2> = <R6#R6 = R1 * 10;#>; << <V2>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <T1><V3> = <R5#R5 = R1 * 2;#>;
  <C1><O1> = <F1.0.0>();
}}
>
Input: "<R1>\n<R2>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 404
OOP.Object.Constructor.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<T1#signedtype#><V2> = <R1#1<=R1<=4;#>;<< <V2>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3> = <R2#5<=R2<=9;#>;
  <C1><O2> = <F1.0.0>();
  << <V3>;
}}
>
Type: debug_output
Hardness: 15

# 405
OOP.Object.Constructor.By Client
?
Object.Variable.Public.By Object Function
>
[<R1#1<=R1<=4;#>]
{<C1>{
public:
   <T0><F1.0.0>(){<T1#signedtype#><V2>; >> <V2>; << <V2>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <T1><V3> = <R5#R5 = R1 * 2;#>;
  <C1><O1> = <F1.0.0>();
  << <V3>;
  <C1><O2> = <F1.0.0>();
}}
>
Input: "<R1>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 15 

// ---------------------------------------------------------------------------------
// // Execution of constructor with one or more parameters - 425
// Object.Initialization.Basic object

// Will not give credit to Constructor.By Client because
//  here, a data member will be updated.
//  In Constructor.By Client, it is only about constructor code being executed, not data members being initialized

# 425
OOP.Object.Initialization.Basic object
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>){<V1> = <V2>;<< <V1>;<< <V1> + 1;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

# 426
OOP.Object.Initialization.Basic object
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>){<V1> = <V2>;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V3> = <R1#1<=R1<=9;#>;
  << <V3>;
  <C1><O1> = <F1.0.0>( <V3> );
}}
>
Type: debug_output
Hardness: 10 

# 427
OOP.Object.Initialization.Basic object
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>){<V1> = <V2>;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V3>;
  >> <V3>;
  <C1><O1> = <F1.0.0>( <V3> );
  << <V3>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 428
OOP.Object.Initialization.Basic object
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>, <T1><V3> ){<V1> = <V2>;<< <V1>;<V4> = <V3>; << <V4>;}
   <T1><V1>;
   <T1><V4>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>( <R1#1<=R1<=4;#>, <R2#5<=R2<=9;#> );
}}
>
Type: debug_output
Hardness: 15

// integrated - post
# 429
OOP.Object.Initialization.Basic object
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>, <T1><V3> ){<V1> = <V2>;<< <V1>;<V6> = <V3>; << <V6>;}
   <T1><V1>;
   <T1><V6>;
protected: 
private:
}
<T0><F0>(){
  <T1><V4> = <R1#1<=R1<=4;#>;
  <T1><V5> = <R2#5<=R2<=9;#>;
  <C1><O1> = <F1.0.0>( <V4>, <V5> );
}}
>
Type: debug_output
Hardness: 15 

# 430
OOP.Object.Initialization.Basic object
?
Object.{Constructor.By Client,Variable.Public.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>, <T1><V3> ){<V1> = <V2>;<< <V1>;<V6> = <V3>; << <V6>;}
   <T1><V1>;
   <T1><V6>;
protected: 
private:
}
<T0><F0>(){
  <T1><V4>;
  >> <V4>;
  <T1><V5>;
  >> <V5>;
  <C1><O1> = <F1.0.0>( <V4>, <V5> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 15 

// ---------------------------------------------------------------------------------
// // Execution of constructor with incorrect number of parameters - 450
// Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
// 0-1, 1-0, 0-2, 2-0, 1-2, 2-1

# 450
OOP.Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R2#11<=R2<=19;#>;<< <V1>;}
   <T1#signedtype#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

# 451
OOP.Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#> <V2>){<V1> = <V2>; << <V1>; << <V2>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
}}
>
Type: debug_output
Hardness: 10 

# 452
OOP.Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(){>> <V1>; while( <V1> % 2 == 0 ){>> <V1>;} << <V1>;}
   <T1#signedtype#><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V3>;   >> <V3>;
  <T1><V4>;   >> <V4>;  
  <C1><O1> = <F1.0.0>( <V3>, <V4> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 453
OOP.Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>, <T1><V3>){if( <V2> > <V3> ){<V1> = <V2> % <V3>;} else {<V1> = <V3> % <V2>;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V4> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  << <V4>;
}}
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 454
OOP.Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>){if( <V2> % 2 == 0 ){<V1> = <V2> * 10;} else {<V1> = <V2> + 10;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V3>;   >> <V3>;
  <T1><V4>;   >> <V4>;  
  <C1><O1> = <F1.0.0>( <V3>, <V4> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// integrated - post
# 455
OOP.Object.Constructor.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>, <T1><V3>){if( <V2> < <V3> ){<V1> = <V2>;} else {<V1> = <V3>;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V4> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>( <V4> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of constructor with incorrect data types for parameters - 475
// Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition

// Only using examples with real actual and integer formal parameter, and not vice versa

# 475
OOP.Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#integer#><V2>){<V1> = <V2> * 10;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2#real#><V3> = <R1#float;1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>( <V3> );
}}
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 476
OOP.Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#integer#><V2>, <T1><V3>){<V1> = <V2> / <V3> + <V2> % <V3>; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V4> = <R1#1<=R1<=9;#>;
  <T2#real#><V5> = <R2#float;1<=R2<=9;#>;
  <C1><O1> = <F1.0.0>( <V4>, <V5> );
}}
>
Type: debug_output
Hardness: 10 

// integrated - post
# 477
OOP.Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#integer#><V2>, <T1><V3>){<V1> = (<V2> + <V3>) * (<V2> - <V3>); << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2#real#><V5> = <R2#float;1<=R2<=9;#>;
  << <V5>;
  <T1><V4> = <R1#1<=R1<=9;#>;
  << <V4>;
  <C1><O1> = <F1.0.0>( <V5>, <V4> );
}}
>
Type: debug_output
Hardness: 10 

# 478
OOP.Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T2#real#><V3>, <T1#integer#><V2>){<V1> = <V2> * <V2>; << <V1>; << <V3>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2><V4> = <R2#float;1<=R2<=9;#>;
  <T2><V5>;
  <V5> = <V4> * 2;
  <C1><O1> = <F1.0.0>( <V4>, <V5> );
}}
>
Type: debug_output
Hardness: 10 

# 479
OOP.Object.Constructor.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#integer#><V2>, <T2#real#><V3>){<V1> = <V2> % 2; << <V3>; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2><V4> = <R2#float;1<=R2<=9;#>;
  << <V4>;
  <C1><O1> = <F1.0.0>( <V4>, <V4> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) wrt object - 500
// Object.Selector.By Client

# 500
OOP.Object.Selector.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 

# 501
OOP.Object.Selector.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  <C1><O1> = <F1.0.0>();
  <V2> = <O1>.<F1.1.0>();
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

# 502
OOP.Object.Selector.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){>> <V1>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1.1.0>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 503
OOP.Object.Selector.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=8;#>; << <V1>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  <C1><O1> = <F1.0.0>();
  <V2> = <O1>.<F1.1.0>();
  << <V2>;
}}
>
Type: debug_output
Hardness: 15

# 504
OOP.Object.Selector.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>; << <V1>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 15 

// integrated - pre
# 505
OOP.Object.Selector.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){>> <V1>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  <C1><O1> = <F1.0.0>();
  <V2> = <O1>.<F1.1.0>();
  << <V2>;
  << <O1>.<F1.1.0>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 15

// integrated - post
# 506
OOP.Object.Selector.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){>> <V1>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1><O2> = <F1.0.0>();
  << <O1>.<F1.1.0>();
  << <O2>.<F1.1.0>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 15

// ---------------------------------------------------------------------------------
// // Value returned by the selector is ignored by the caller - 525
// Object.Selector.Value returned by the function is ignored by the caller

# 525
OOP.Object.Selector.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 

# 526
OOP.Object.Selector.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.0>();
  <T1><V2> = 0;
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

# 527
OOP.Object.Selector.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){>> <V1>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.0>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 528
OOP.Object.Selector.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=8;#>; << <V1>; <V1> = <V1> + <R2#5<=R2<=9;#>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <R2>;
  <O1>.<F1.1.0>();
  << <V2>;
}}
>
Type: debug_output
Hardness: 15

# 529
OOP.Object.Selector.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<V1> = <R1#5<=R1<=9;#>; << <V1>; <V1> = <V1> - <R2#2<=R2<=4;#>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 15 

# 530
OOP.Object.Selector.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T1#float#><F1.1.0>(){<V1> = <R1#float;1<=R1<=9;#>;if( <V1> < 5.0 ){ << <V1>;} else { << <V1> - 5.0;} return <V1> * 2;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Selector is called before data member is initialized - 550
// Object.Selector.Referencing variable before initializing its value
// Java compiler initializes value to zero anyway - do not use for Java

# 550
OOP.Object.Selector.Referencing variable before initializing its value
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.1.0>(){<< <V1>;}
   <T1#signedtype#><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 

# 551
OOP.Object.Selector.Referencing variable before initializing its value
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<< <V1>; <V1> = <R1#5<=R1<=9;#>; return <V1>; }
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 10 

# 552
OOP.Object.Selector.Referencing variable before initializing its value
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<< <V1>; >> <V1>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1.1.0>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 553
OOP.Object.Selector.Referencing variable before initializing its value
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<< <V1>; <V1> = <R1#5<=R1<=9;#>; return <V1>; }
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2>;
  <V2> = <O1>.<F1.1.0>();
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

// integrated - post
# 554
OOP.Object.Selector.Referencing variable before initializing its value
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<< <V1>; >> <V1>; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  <C1><O1> = <F1.0.0>();
  <V2> = <O1>.<F1.1.0>();
  << <V2>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) wrt object - 600
// Object.Mutator.By Client

# 600
OOP.Object.Mutator.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#integer#><V3>){<V1> = <V3>; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <R1#1<=R1<=8;#> );
}}
>
Type: debug_output
Hardness: 10 

# 601
OOP.Object.Mutator.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#integer#><V3>){<V1> = <V3>; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  << <V2>;
  <O1>.<F1.1.1>( <V2> );
}}
>
Type: debug_output
Hardness: 10 

# 602
OOP.Object.Mutator.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#integer#><V3>){<V1> = <V3>; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  <C1><O1> = <F1.0.0>();
  >> <V2>;
  <O1>.<F1.1.1>( <V2> );
  << <V2>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// integrated - pre
# 603
OOP.Object.Mutator.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#integer#><V3>){ << <V3>; if( <V3> > <R2#4<=R2<=6;#> ) { <V1> = <V3>; } else{ <V1> = 0; } << <V1>;  }
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <R1#1<=R1<=8;#> );
}}
>
Type: debug_output
Hardness: 10 

// integrated - post
# 604
OOP.Object.Mutator.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#integer#><V3>){ <V1> = <V3>; << <V1>; if( <V3> < <R2#5<=R2<=9;#> ){ <V1> = <V1> + 1;} else { <V1> = <V1> - 1;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#1<=R1<=4;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2> );
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

# 605
OOP.Object.Mutator.By Client
?
Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#integer#><V3>){ if( <V3> < 0 ) { <V1> = <V3>; } else { >> <V1>; } << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  <C1><O1> = <F1.0.0>();
  >> <V2>;
  <O1>.<F1.1.1>( <V2> );
  << <V2>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Value returned by the mutator is ignored by the caller - 625
// Object.Mutator.Value returned by the function is ignored by the caller

# 625
OOP.Object.Mutator.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T2#bool#><F1.1.1>(<T1#signedtype#><V3>){if(<V3> >= 0){<V1> = <V3>; << <V1>; return true;} else {<V1> = <V3> * -1; << <V1>;return false;}}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#-9<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2> );
}}
>
Type: debug_output
Hardness: 10 

# 626
OOP.Object.Mutator.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T2#bool#><F1.1.1>(<T1#integer#><V3>){ if( <V3> > <R2#4<=R2<=6;#> ) { <V1> = <V3>;  << <V1>; return true; } else{ <V1> = 0; << <V1>; return false;}  }
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <R1#1<=R1<=8;#> );
}}
>
Type: debug_output
Hardness: 10 

# 627
OOP.Object.Mutator.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T2#bool#><F1.1.1>(<T1#integer#><V3>){ <V1> = <V3>; << <V1>; if( <V3> % 2 == 0 ){ return true; } else { return false; } }
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#1<=R1<=8;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2> );
  << <V2>;
}}
>
Type: debug_output
Hardness: 10 

# 628
OOP.Object.Mutator.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T2#bool#><F1.1.1>(<T1#integer#><V3>){ if( <V3> < 0 ) { <V1> = <V3>; << <V1>; return true; } else { >> <V1>; << <V1>; return false; } }
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  <C1><O1> = <F1.0.0>();
  >> <V2>;
  <O1>.<F1.1.1>( <V2> );
  << <V2>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 629
OOP.Object.Mutator.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T2#bool#><F1.1.1>(<T1#integer#><V3>){ >> <V1>; if( <V3> < <V1> ) { <V1> = <V3>; << <V1>; return true; } else { << <V1>; return false; } }
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2>;
  >> <V2>;
  <O1>.<F1.1.1>( <V2> );
  << <V2>;
}}
>
Input: "<R1#5<=R1<=9;#>\n<R2#1<=R2<=4;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 630
OOP.Object.Mutator.Value returned by the function is ignored by the caller
>
{<C1>{
public:
   <T2#bool#><F1.1.1>(<T1#integer#><V3>, <T1><V4> ){ if( <V3> > <V4> ) { <V1> = <V3>; << <V1>; return true; } else { <V1> = <V4>; << <V1>; return false; } }
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <R1#1<=R1<=4;#>, <R2#5<=R2<=9;#> );
}}
>
Type: debug_output
Hardness: 10 



// ---------------------------------------------------------------------------------
// // Mutator is called with incorrect number of parameters - 650
// Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
// 0-1, 0-2, 2-1, 1-2

# 650
OOP.Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>){<V1> = <V3>; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>();
}}
>
Type: debug_output
Hardness: 10 

# 651
OOP.Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>, <T1><V4>){if( <V3> > <V4> ) {<V1> = <V3> / <V4>;} else {<V1> = <V3> % <V4>;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>();
}}
>
Type: debug_output
Hardness: 10 

# 652
OOP.Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>){ <V1> = <V3>; if( <V1> < 0 ) {<V1> = <V1> * -1;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2>, <V2> );
}}
>
Type: debug_output
Hardness: 10 

# 653
OOP.Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>, <T1><V4>){if( <V3> > <V4> ) {<V1> = <V3> - <V4>;} else {<V1> = <V4> - <V3>;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2> );
}}
>
Type: debug_output
Hardness: 10 

# 654
OOP.Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>){ >> <V1>; while( <V1> < <V3> ){ >> <V1>; } << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  <T1><V4>;
  <C1><O1> = <F1.0.0>();
  >> <V2>;
  >> <V4>;
  <O1>.<F1.1.1>( <V2>, <V4> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 655
OOP.Object.Mutator.Number of actual parameters in the call not equal to the number of formal parameters in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>, <T1><V4>){>> <V1>; if( <V1> < <V3> || <V1> > <V4> ) {<V1> = (<V4> - <V3>) / 2;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  <C1><O1> = <F1.0.0>();
  >> <V2>;
  <O1>.<F1.1.1>( <V2> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Mutator is called with incorrect data type for parameters - 675
// Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition

# 675
OOP.Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>){<V1> = <V3>; << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2#real#> <V2> = <R1#float;1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2> );
}}
>
Type: debug_output
Hardness: 10 

# 676
OOP.Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>, <T1><V4>){ <V1> = <V4>; if( <V1> < <V3> ) {<V1> = <V1> * 2;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2#real#><V5> = <R2#float;1<=R2<=9;#>;
  <T1><V2> = <R1#1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V5>, <V2> );
}}
>
Type: debug_output
Hardness: 10 

# 677
OOP.Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>, <T1><V4>){ <V1> = <V3> - <V4>; if( <V1> < 0 ) {<V1> = <V1> * -1;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2> = <R1#1<=R1<=9;#>;
  <T2#real#><V5> = <R2#float;1<=R2<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V2>, <V5> );
}}
>
Type: debug_output
Hardness: 10 

# 678
OOP.Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>, <T1><V4>){ >> <V1>; while( <V1> > <V3> && <V1> < <V4> ){ >> <V1>; } << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  >> <V2>;
  <T2#real#><V5> = <R5#float;1<=R5<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V5>, <V2> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 679
OOP.Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>, <T1><V4>){<T1><V6>; >> <V6>; <V1> = 0; while( <V6> == <V3> || <V6> == <V4> ){ <V1>++; >> <V6>; } << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T1><V2>;
  <T2#real#><V5> = <R5#float;1<=R5<=9;#>;
  <C1><O1> = <F1.0.0>();
  >> <V2>;
  <O1>.<F1.1.1>( <V2>, <V5> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

# 680
OOP.Object.Mutator.Data type of the actual parameter in the call is incompatible with the data type of the formal parameter in the definition
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>, <T2#real#><V4>){ <V1> = <V3>; << <V1>; if( <V4> > 0 ) {<V1> *= <V1>;} << <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <T2><V5> = <R2#float;1<=R2<=9;#>;
  <T2><V2> = <R1#float;1<=R1<=9;#>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V5>, <V2> );
}}
>
Type: debug_output
Hardness: 10 

// Could have additional templates: 2 real actual parameters, only one real formal parameter

// ---------------------------------------------------------------------------------
// // Execution of destructor code (B) wrt object - 700
// Object.Destructor.By Client

# 700
OOP.Object.Destructor.By Client
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>, <T2#real#><V4>){ <V1> = <V3>; << <V1>; if( <V4> > 0 ) {<V1> *= <V1>;} << <V1>;}   
   <T0><F1.0.1>(){<< <R1#1<=R1<=9;#>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <R2#R2 = R1 * 10;#>;
  << <V2>;
}}
>
Type: debug_output
Languages: C++ C#
Hardness: 10 

// integrated - pre
# 701
OOP.Object.Destructor.By Client
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>){ >> <V1>; while( <V1> < <V3> ){ >> <V1>; } << <V1>;}
   <T0><F1.0.1>(){<T1><V3> = <R1#1<=R1<=9;#>;<< <V3>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <T1><V2> = <R2#R2 = R1 + 1;#>;
  <C1><O1> = <F1.0.0>();
  << <V2>;
}}
>
Type: debug_output
Languages: C++ C#
Hardness: 10 

# 702
OOP.Object.Destructor.By Client
>
{<C1>{
public:
   <T2#bool#><F1.1.1>(<T1#integer#><V3>){ if( <V3> < 0 ) { <V1> = <V3>; << <V1>; return true; } else { >> <V1>; << <V1>; return false; } }
   <T0><F1.0.1>(){<T1><V3> = <R1#1<=R1<=4;#>;<< <V3>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <T1><V2>;
  >> <V2>;
  <C1><O1> = <F1.0.0>();
  << <V2>;
}}
>
Input: "<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Languages: C++ C#
Hardness: 10 

// integrated - post
# 703
OOP.Object.Destructor.By Client
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>; return <V1>;}
   <T0><F1.0.1>(){<T1><V3> = <R1#1<=R1<=9;#>;<< <V3>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <R2#R2 = R1 + 1;#>;
  << <V2>;
}}
>
Type: debug_output
Languages: C++ C#
Hardness: 10 

# 704
OOP.Object.Destructor.By Client
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V3>){ <V1> = <V3>; if( <V3> < <R2#5<=R2<=9;#> ){ <V1> = <V1> + 1;} else { <V1> = <V1> - 1;} << <V1>;}
   <T0><F1.0.1>(){<T1><V3> = <R1#1<=R1<=4;#>;<< <V3>;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <T1><V2>;
  <C1><O1> = <F1.0.0>();
  >> <V2>;
  << <V2>;
}}
>
Input: "<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Languages: C++ C#
Hardness: 10 

# 705
OOP.Object.Destructor.By Client
>
{<C1>{
public:
   <T0><F1>(){<T1#signedtype#><V2>; >> <V2>; if( <V2> > <V1> ){ << <V2>; } else {<< <V2> + 1; }}
   <T0><F1.0.1>(){<T1><V3> = <R1#1<=R1<=9;#>;<< <V3>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <R2#R2 = R1 + 10;#>;
  <C1><O2> = <F1.0.0>();
  << <V2>;
}}
>
Input: "<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Languages: C++ C#
Hardness: 20 

// ---------------------------------------------------------------------------------
// ON SECOND THOUGHTS, THESE PROBLEMS MAKE NO SENSE IN EITHER C++ OR JAVA
// // Assigning an object to class instead of another object - 800
// Object.Assignment.Aggregate.Assigning to class
// Object.Assignment.Aggregate.Object cannot be assigned to a class
// C++:
// student jane( 2345 );
// student = jane;
// or
// student ( 2345 ); // NO, Ignore
// Java:
// Student jane = new Student( 2345 );
// Student = jane;
// or
// Student = new Student( 2345 ); // NO, Ignore

// # 800
// OOP.Object.Assignment.Aggregate.Object cannot be assigned to a class
// >
// {<C1>{
// public:
//    <T0><F1.0.0>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;}
//    <T1#signedtype#><V1>;
// protected: 
// private:
// }
// <T0><F0>(){
//   <C1><O1> = <F1.0.0>();
//   <C1> = <O1>;
//   << <R2#R2 = R1 * 10;#>;
// }}
// >
// Type: debug_output
// Languages: C++
// Hardness: 10 
// 
// # 801
// OOP.Object.Assignment.Aggregate.Object cannot be assigned to a class
// >
// {<C1>{
// public:
//    <T0><F1.0.0>(){>> <V1>;<V1> = <V1> * 10;<< <V1>;}
//    <T1#signedtype#><V1>;
// protected: 
// private:
// }
// <T0><F0>(){
//   <C1><O1> = <F1.0.0>();
//   <C1> = <O1>;
//   <T1><V2>;   >> <V2>;
//   <V2> = <V2> * <V2>;
//   << <V2>;
// }}
// >
// Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
// >
// Type: debug_output
// Languages: C++
// Hardness: 10 

// ---------------------------------------------------------------------------------
// // Aggregate assignment from one object to another - 825
// Object.Assignment.Aggregate.Assigning object to variabl


// FROM HERE


# 825
OOP.Object.Assignment.Aggregate.Assigning object to variable
?
Object.{Constructor.By Client,Variable.Public.By Object Function,Selector.By Client}
>
{<C1>{
public:
   <T0><F1.0.0>(){>> <V1>;<< <V1>;}
   <T1#signedtype#><F1.1.0>(){return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1><O2> = <F1.0.0>();
  <O1> = <O2>;
  << <O1>.<V1>;
  << <O1>.<F1.1.0>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Object passed as parameter to a function where it is accessed - 850
// Object.Parameter.Aggregate.Accessed
// To show that state of object is preserved through function call:
//    caller assigns to a public variable, callee prints public variable
//    caller assigns to a public variable, callee calls selector
//    caller calls mutator, callee prints public variable
//    caller calls mutator, callee calls selector

# 850
OOP.Object.Parameter.Aggregate.Accessed
?
Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1#signedtype#><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
//  <C1><O3> = <F1.0.0>();
//  <O3>.<V1> = 2;
//  << <O3>.<V1>;
//  <O2>.<V1> = 3;
//  <T1><V2>;
  << <O2>.<V1>;
//  <V2> = <O2>.<V1>;
//  << <V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#1<=R1<=9;#>;
//  << <O1>.<V1>;
  <F1>( <O1> );
}}
>
Type: debug_output
Hardness: 10 

# 851
OOP.Object.Parameter.Aggregate.Accessed
?
Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1#signedtype#><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  << <O2>.<V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  >> <O1>.<V1>;
  <F1>( <O1> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 10 



# 855
OOP.Object.Parameter.Aggregate.Accessed
?
Object.{Variable.Public.{By Client,By Object Function},Selector.By Client}
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T1><F1.1.0>(){return <V1>;}
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <V2> = <O2>.<F1.1.0>();
  << <V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#1<=R1<=9;#>;
  <F1>( <O1> );
}}
>
Type: debug_output
Hardness: 20

# 856
OOP.Object.Parameter.Aggregate.Accessed
?
Object.{Variable.Public.{By Client,By Object Function},Selector.By Client}
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <T1><V2>;
  <V2> = <O2>.<F1.1.0>();
  << <V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  >> <O1>.<V1>;
  <F1>( <O1> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 20 



# 860
OOP.Object.Parameter.Aggregate.Accessed
?
Object.{Variable.Public.{By Client,By Object Function},Mutator.By Client}
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T0><F1.1.1>(<T1><V3>){<V1>=<V3>;}
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <T1><V2>;
  <V2> = <O2>.<V1>;
  << <V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>(<R1#1<=R1<=9;#>);
  <F1>( <O1> );
}}
>
Type: debug_output
Hardness: 20 

# 861
OOP.Object.Parameter.Aggregate.Accessed
?
Object.{Variable.Public.{By Client,By Object Function},Mutator.By Client}
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V2>){<V1>=<V2>;}
   <T1><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  << <O2>.<V1>;
}
<T0><F0>(){
  <T1><V3>;
  <C1><O1> = <F1.0.0>();
  >> <V3>;
  <O1>.<F1.1.1>(<V3>);
  <F1>( <O1> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 20 



# 865
OOP.Object.Parameter.Aggregate.Accessed
?
Object.{Variable.Public.{By Client,By Object Function},Selector.By Client,Mutator.By Client}
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T1><F1.1.0>(){return <V1>;}
   <T0><F1.1.1>(<T1><V3>){<V1>=<V3>;}
protected: 
private:
}
<T0><F1>(<C1><O2>){
  << <O2>.<F1.1.0>();
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>(<R1#1<=R1<=9;#>);
  <F1>( <O1> );
}}
>
Type: debug_output
Hardness: 30 

// integrated - pre, post - deliberately the most complex, in case students satisfy selector/mutator learnobj
# 866
OOP.Object.Parameter.Aggregate.Accessed
?
Object.{Variable.Public.{By Client,By Object Function},Selector.By Client,Mutator.By Client}
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V2>){<V1>=<V2>;}
   <T1><F1.1.0>(){return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <T1><V4>;
  <V4> = <O2>.<F1.1.0>();
  << <V4>;
}
<T0><F0>(){
  <T1><V3>;
  <C1><O1> = <F1.0.0>();
  >> <V3>;
  <O1>.<F1.1.1>(<V3>);
  <F1>( <O1> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 30 





// ---------------------------------------------------------------------------------
// // Object passed as parameter to a function where it is modified - 875
// Object.Parameter.Aggregate.Modified
// To show that state of object is (not) modified by callee (C++)/Java/C#:
//    callee assigns to a public variable, caller prints public variable
//    callee assigns to a public variable, caller calls selector
//    callee calls mutator, caller prints public variable
//    callee calls mutator, caller calls selector

# 875
OOP.Object.Parameter.Aggregate.Modified
?
Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1#signedtype#><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <O2>.<V1> = <R2#5<=R2<=9;#>;;
  << <O2>.<V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#1<=R1<=4;#>;
  <F1>( <O1> );
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 10 

# 876
OOP.Object.Parameter.Aggregate.Modified
?
Object.Variable.Public.By Client
>
{<C1>{
public:
   <T1#signedtype#><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  >> <O2>.<V1>;
  << <O2>.<V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  >> <O1>.<V1>;
  <F1>( <O1> );
  << <O1>.<V1>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 10 


# 880
OOP.Object.Parameter.Aggregate.Modified
?
Object.{Variable.Public.{By Client,By Object Function},Selector.By Client}
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T1><F1.1.0>(){return <V1>;}
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <T1><V2>;
  <O2>.<V1> = <R2#5<=R2<=9;#>;
  <V2> = <O2>.<F1.1.0>();
  << <V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<V1> = <R1#1<=R1<=4;#>;
  <F1>( <O1> );
  <T1><V3> = <O1>.<F1.1.0>();
  << <V3>;
}}
>
Type: debug_output
Hardness: 20

# 881
OOP.Object.Parameter.Aggregate.Modified
?
Object.{Variable.Public.{By Client,By Object Function},Selector.By Client}
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <T1><V2>;
  >> <O2>.<V1>;
  <V2> = <O2>.<F1.1.0>();
  << <V2>;
}
<T0><F0>(){
  <T1><V3>;
  <C1><O1> = <F1.0.0>();
  >> <O1>.<V1>;
  <F1>( <O1> );
  <V3> = <O1>.<F1.1.0>();
  << <V3>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 20 


# 885
OOP.Object.Parameter.Aggregate.Modified
?
Object.{Variable.Public.{By Client,By Object Function},Mutator.By Client}
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T0><F1.1.1>(<T1><V3>){<V1>=<V3>;}
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <T1><V2>;
  <O2>.<F1.1.1>(<R2#1<=R2<=4;#>);
  <V2> = <O2>.<V1>;
  << <V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>(<R1#5<=R1<=9;#>);
  <F1>( <O1> );
  << <O1>.<V1>;
}}
>
Type: debug_output
Hardness: 20 

# 886
OOP.Object.Parameter.Aggregate.Modified
?
Object.{Variable.Public.{By Client,By Object Function},Mutator.By Client}
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V2>){<V1>=<V2>;}
   <T1><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <T1><V4>;
  >> <V4>;
  <O2>.<F1.1.1>(<V4>);
  << <O2>.<V1>;
}
<T0><F0>(){
  <T1><V3>;
  <C1><O1> = <F1.0.0>();
  >> <V3>;
  <O1>.<F1.1.1>(<V3>);
  <F1>( <O1> );
  <T1><V5> = <O1>.<V1>; 
  << <V5>;
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 20 


// integrated - pre, post - deliberately the most complex, in case students satisfy selector/mutator learnobj
# 890
OOP.Object.Parameter.Aggregate.Modified
?
Object.{Variable.Public.{By Client,By Object Function},Selector.By Client,Mutator.By Client}
>
{<C1>{
public:
   <T1#signedtype#><V1>;
   <T1><F1.1.0>(){return <V1>;}
   <T0><F1.1.1>(<T1><V3>){<V1>=<V3>;}
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <T1><V2>;
  <O2>.<F1.1.1>(<R2#1<=R2<=4;#>);
  <V2> = <O2>.<F1.1.0>();
  << <V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>(<R1#5<=R1<=9;#>);
  <F1>( <O1> );
  << <O1>.<F1.1.0>();
}}
>
Type: debug_output
Hardness: 30 

# 891
OOP.Object.Parameter.Aggregate.Modified
?
Object.{Variable.Public.{By Client,By Object Function},Selector.By Client,Mutator.By Client}
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V2>){<V1>=<V2>;}
   <T1><F1.1.0>(){return <V1>;}
   <T1><V1>;
protected: 
private:
}
<T0><F1>(<C1><O2>){
  <T1><V4>;
  >> <V4>;
  <O2>.<F1.1.1>(<V4>);
  << <O2>.<F1.1.0>();
}
<T0><F0>(){
  <T1><V3>;
  <C1><O1> = <F1.0.0>();
  >> <V3>;
  <O1>.<F1.1.1>(<V3>);
  <F1>( <O1> );
  <V3> = <O1>.<F1.1.0>();
  << <V3>;  
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=19;#>"
>
Type: debug_output
Hardness: 30 


// =================================================================================
// // STATIC VARIABLE AND FUNCTION IN A CLASS
// ---------------------------------------------------------------------------------


// // Accessing public (D) data member by static member function - 300
// // Accessing protected (D) data member by static member function 
// // Accessing private (D) data member by static member function  

// Object.Variable.Public.By Class Function
// Object.Variable.Protected.By Class Function
// Object.Variable.Private.By Class Function

// Object.Variable.Public.Class (static) function does not have access to public data member of the object
// Object.Variable.Protected.Class (static) function does not have access to protected data member of the object
// Object.Variable.Private.Class (static) function does not have access to private data member of the object

# 300
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed in a static function
>
{<C1>{
public:
   static <T0><F1>(<T1#signedtype#><V2>){<V1> = <V2>;}
   <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <O1>.<F1.0.0>();
  <C1>.<F1>(<R1#0<=R1<=9;#>);
}}
>
Type: debug_output
Hardness: 10 

# 301
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed in a static function
>
{<C1>{
public:
   static <T0><F1>(){<T1#signedtype#><V2>;>> <V1>;>> <V2>;<< <V2> - 10;}
protected: 
   <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>();
}}
>
Input: "<R1#0<=R1<=8;#>\n<R2#R2 = R1 + 10;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Hardness: 10 

# 302
OOP.Object.Variable.The variable is not a static member of the class and cannot be accessed in a static function
>
{<C1>{
public:
   static <T0><F1>(<T1#signedtype#><V3>){<T1><V2>;<V2> = <V3>;<V1> = <R1#0<=R1<=9;#>;}
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>(<R2#R2 = R1 * 10;#>);
}}
>
Type: debug_output
Hardness: 10 
// ---------------------------------------------------------------------------------



// // Accessing static public (B) data member by client - 1000
// Class.Variable.Public.Wrt Class

# 1000
OOP.Class.Variable.Public.Wrt Class
>
{<C1>{
public:
   static <T1#signedtype#> <V1>;
   <T0><F1>(){>> <V2>;<< <V2>;}
protected: 
private:
   <T1><V2>;
}
<T0><F0>(){
  <C1>.<V1> = <R3#11<=R3<=19;#>;
  << <C1>.<V1>;
}}
>
Input: "<R1#0<=R1<=4;#>\n<R2#5<=R2<=9;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static public (B) data member by client - 1025
// Class.Variable.Public.Wrt Object

# 1025
OOP.Class.Variable.Public.Wrt Object
>
{<C1>{
public:
   <T0><F1>(){>> <V2>;<< <V2>;}
   static <T1#signedtype#> <V1>;
protected: 
private:
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();   >> <O1>.<V1>;
}}
>
Input: "<R1#0<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static protected (D) data member by client - 1050
// Class.Variable.Protected.By Client

# 1050
OOP.Class.Variable.Protected.By Client
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V3>){<V2> = <V3>;<< <V2>;}
protected: 
   static <T1> <V1>;
private:
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<V1> = <R2#5<=R2<=9;#>;
  <O1>.<F1>(<R1#0<=R1<=4;#>);
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static private (D) data member by client - 1075
// Class.Variable.Private.By Client

# 1075
OOP.Class.Variable.Private.By Client
>
{<C1>{
public:
   <T0><F1>(){>> <V2>;<< <V2> + 1;>> <V2>;<< <V2> - 1;}
protected: 
private:
   <T1><V2>;
   static <T1> <V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();   >> <C1>.<V1>;
  <O1>.<F1>();
}}
>
Input: "<R1#0<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R1 + 10;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static public (B) data member by static member function - 1100
// Class.Variable.Public.By Class Function

# 1100
OOP.Class.Variable.Public.By Class Function
?
Class.Function.Public.Wrt Class
>
{<C1>{
public:
   static <T1#signedtype#><F1>(){<V1> = <R1#1<=R1<=9;#>;return <V1>;}
   static <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  << <C1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static protected (B) data member by static member function - 1125
// Class.Variable.Protected.By Class Function

# 1125
OOP.Class.Variable.Protected.By Class Function
?
Class.Function.Public.Wrt Class
>
{<C1>{
public:
   static <T1#signedtype#><F1>(){>> <V1>;<< <V1>;>> <V1>;return <V1>;}
protected: 
   static <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <C1>.<F1>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R1 + 10;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static private (B) data member by static member function - 1150
// Class.Variable.Private.By Class Function

# 1150
OOP.Class.Variable.Private.By Class Function
?
Class.Function.Public.Wrt Class
>
{<C1>{
public:
   static <T0><F1>(){>> <V1>;<V1> = <V1> * 10;<< <V1>;}
protected: 
private:
   static <T1#signedtype#><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>();
}}
>
Input: "<R1#1<=R1<=9;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R1 + 10;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static public (D) data member by dynamic member function - 1200
// Class.Variable.Public.By Object Function

# 1200
OOP.Class.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1>(){<V1> = <R1#1<=R1<=9;#>;<V1> = <V1> * 10;return <V1>;}
   static <T1><V1>;
protected: 
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static protected (D) data member by dynamic member function - 1225
// Class.Variable.Protected.By Object Function

# 1225
OOP.Class.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1>(){>> <V1>;<V1> = <V1> + 10;return <V1>;}
protected: 
   static <T1><V1>;
private:
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R1 + 10;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static private (D) data member by dynamic member function - 1250
// Class.Variable.Private.By Object Function

# 1250
OOP.Class.Variable.Private.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1>(){>> <V1>;<V1> = <V1> + 1;return <V1>;}
protected: 
private:
   static <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F1>();
  << <O1>.<F1>();
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#R3 = R1 + 10;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static public (B) member function wrt class name by client - 1300
// Class.Function.Public.Wrt Class

# 1300
OOP.Class.Function.Public.Wrt Class
>
{<C1>{
public:
//   static <T0><F2>(){<T1#signedtype#><V3> = <R3#1<=R3<=9;#>;<V3> = <V3> + 10;<< <V3>;}
//   static <T0><F1>(){<T1#signedtype#><V2> = <R1#1<=R1<=9;#>;<V2> = <V2> * 10;<< <V2>;<C1>.<F2>();}
   static <T0><F1>(){<T1#signedtype#><V2> = <R1#1<=R1<=9;#>;<V2> = <V2> * 10;<< <V2>;}
   <T0><F1.0.0>(){<V1> = <R2#11<=R2<=19;#>;} 
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>();
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static public (D) member function wrt object by client - 1325
// Class.Function.Public.Wrt Object

# 1325
OOP.Class.Function.Public.Wrt Object
>
{<C1>{
public:
   static <T0><F1>(<T1#signedtype#><V3>){<T1><V2> = <V3>;<V2> = <V2> + 10;<< <V2>;}
   <T0><F1.0.0>(){<V1> = <R2#11<=R2<=19;#>; <V1> = <V1> - 10; << <V1>;} 
protected: 
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static protected (D) member function by client - 1350
// Class.Function.Protected.By Client

# 1350
OOP.Class.Function.Protected.By Client
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=9;#>;} 
protected: 
   static <T0><F1>(){<T1#signedtype#><V2>;>> <V2>;<V2> = <V2> * 10;<< <V2>;>> <V2>;<V2> = <V2> + 10;<< <V2>;}
private:
   <T1><V1>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>();
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing static private (D) member function by client - 1375
// Class.Function.Private.By Client

# 1375
OOP.Class.Function.Private.By Client
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=9;#>;} 
protected: 
   <T1#signedtype#><V1>;
private:
   static <T0><F1>(<T1><V3>){<T1><V2>;>> <V2>;<V2> = <V2> + <V3>;<< <V2>;>> <V2>;<V2> = <V2> - <V3>;<< <V2>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <C1>.<F1>( <R1#1<=R1<=5;#> );
}}
>
Input: "<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Hardness: 10 


// =================================================================================
// REVISIT DIFFEREING SYNTAXES FOR C++ AND JAVA//C# FROM HERE-ONWARDS AND INTRODUCE LANGUAGES TAG AS APPROPRIATE
// =================================================================================
// // COMPOSITION OF CLASSES
// // Called in Composer function, which is in turn called by client
// ---------------------------------------------------------------------------------
// // Accessing public (B) data member by composing class - 2000
// Object.Variable.Public.By Composer
// ***Technically synonymous with***  Object.Variable.Public.By Client

# 2000
OOP.Object.Variable.Public.By Composer
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><V1>;
protected: 
   <T1><F1>(){<V1>=<R4#0<=R4<=9;#>;return <V1>;}
private:
}
<C2>{
public:
   <T0><F2.0.0>(){<O1> = <F1.0.0>();} 
   <T0><F2>(){>> <O1>.<V1>;<O1>.<V1>++;<< <O1>.<V1>;} 
   <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();
  <O2>.<F2>();
}}
>
Input: "<R1#0<=R1<=8;#>\n<R2#R2 = R1 + 10;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member by composing class - 2025
// Object.Variable.Protected.By Composer
// ***Technically synonymous with***  Object.Variable.Protected.By Client

# 2025
OOP.Object.Variable.Protected.By Composer
?
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1>(){<V1>=<R1#0<=R1<=9;#>;return <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public: 
  <T0><F2>(){<T1><V2> = <R2#10<=R2<=19;#>;<O1>.<V1>=<V2>;<< <V2>;} 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();} 
protected:
   <C1><O1>;
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();
  <O2>.<F2>();
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member by composing class - 2050
// Object.Variable.Private.By Composer
// ***Technically synonymous with***  Object.Variable.Private.By Client

# 2050
OOP.Object.Variable.Private.By Composer
?
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1>(<T1><V4>){<V1>=<V4>;return <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2>{
public: 
  <T0><F2>(<T1><V3>){<O1>.<V1> = <V3>;<< <V3>;} 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();} 
protected:
private: 
   <C1><O1>;
}
<T0><F0>(){
  <T1><V2> = <R1#0<=R1<=9;#>;
  <C2><O2> = <F2.0.0>();
  <O2>.<F2>(<V2>);
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// // Called in Composer function, which is in turn called by client
// ---------------------------------------------------------------------------------
// // Accessing protected (D) member function by composing class - 2100
// Object.Function.Protected.By Composer
// ***Technically synonymous with***  Object.Function.Protected.By Client

# 2100
OOP.Object.Function.Protected.By Composer
?
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
protected: 
   <T0><F1>(){>> <V1>;<V1> = <V1> + 10;<< <V1>;}
   <T1#signedtype#><V1>;
private:
}
<C2>{
public: 
  <T0><F2>(){<T1><V2>;<O1>.<F1>(); >> <V2>; << <V2>;} 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();} 
protected:
   <C1><O1>;
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();
  <O2>.<F2>();
}}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 + 10;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function by composing class - 2125
// Object.Function.Private.By Composer
// ***Technically synonymous with***  Object.Function.Private.By Client

# 2125
OOP.Object.Function.Private.By Composer
?
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
protected: 
private:
   <T0><F1>(<T1#signedtype#><V4>){<V1> = <V4>;<< <V1>;}
   <T1><V1>;
}
<C2>{
public: 
  <T0><F2>(<T1><V3>){<O1>.<F1>(<V3>); << <V3>;} 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();} 
protected:
private: 
   <C1><O1>;
}
<T0><F0>(){
  <T1><V2> = <R1#0<=R1<=9;#>;
  <C2><O2> = <F2.0.0>();
  <O2>.<F2>( <V2> );
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of constructor code (B) by composing class constructor - 2200
// Object.Constructor.By Composer

# 2200
OOP.Object.Constructor.By Composer
?
OOP.Object.Variable.Private.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<T1#signedtype#><V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();<T1><V2> = <R2#6<=R2<=9;#>;<< <V2>;} 
protected:
private: 
  <C1><O1>;
}
<T0><F0>(){
  <T1><V3> = <R3#11<=R3<=19;#>;
  <C2><O2> = <F2.0.0>();
  << <V3>;
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Calling constructor with arguments, some of which are used to initialize composed object - 2225
// Object.Initialization.Composed object

# 2225
OOP.Object.Initialization.Composed object
?
OOP.Object.{Initialization.Basic object,Variable.Private.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>){<V1> = <V2>;<< <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2>{
public:
   <T0><F2.0.0>(<T1><V4>,<T1><V5>){<O1>=<F1.0.0>(<V4>);<V3> = <V5>;<< <V3>;}
protected: 
private:
   <T1><V3>;
   <C1><O1>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>( <R1#1<=R1<=4;#>, <R2#5<=R2<=9;#> );
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

# 2226
OOP.Object.Initialization.Composed object
?
OOP.Object.{Initialization.Basic object,Variable.Protected.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V2>){<V1> = <V2>;<< <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public:
   <T0><F2.0.0>(<T1><V4>,<T1><V5>){<V3> = <V5>;<O1>=<F1.0.0>(<V4>);<< <V3>;}
protected: 
   <T1><V3>;
   <C1><O1>;
private:
}
<T0><F0>(){
  <T1><V6>;   >> <V6>;
  <T1><V7>;   >> <V7>;
  <C2><O2> = <F2.0.0>( <V6>, <V7> );
}}
>
Input: "<R1#1<=R1<=4;#>\n<R2#5<=R2<=9;#>\n<R3#11<=R3<=14;#>\n<R4#15<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by composing class function - 2250
// Object.Selector.By Composer

# 2250
OOP.Object.Selector.By Composer
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>; <V1> = <V1> + 1; return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T0><F1>(){<T1><V2> = <O1>.<F1.1.0>();<< <V2>;} 
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<F1>();
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by composing class function - 2275
// Object.Mutator.By Composer

# 2275
OOP.Object.Mutator.By Composer
?
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F1.1.1>( <T1#signedtype#><V4> ){<V1> = <V4>;<< <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T0><F1>( <T1><V5> ){<O1>.<F1.1.1>( <V5> );<V5> = <V5> + 10;<< <V5>;} 
protected:
  <C1><O1>;
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <T1><V3> = <R1#1<=R1<=9;#>;
  <O2>.<F1>( <V3> );
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of destructor code (B) by composing class destructor - 2300
// Object.Destructor.By Composer

# 2300
OOP.Object.Destructor.By Composer
?
OOP.Object.Variable.Protected.By Object Function
>
{<C1>{
public:
   <T0><F1.0.1>(){<T1#signedtype#><V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T0><F2.0.1>(){<T1><V2> = <R2#6<=R2<=9;#>;<< <V2>;} 
protected:
  <C1><O1>;
private: 
}
<T0><F0>(){
  <T1><V3> = <R3#11<=R3<=19;#>;
  {  <C2><O2> = <F2.0.0>(); 
     <V3> = <V3> - 10; }
  <V3> = <V3> + 1;    
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (D) data member wrt composing object by client - 2400
// Object.Variable.Public.Wrt Composer

# 2400
OOP.Object.Variable.Public.Wrt Composer
?
OOP.Object.Variable.Public.By Client
>
{<C1>{
public:
   <T0><F1.1.1>( <T1#signedtype#><V3> ){<V1> = <V3> % 2;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T1><F2.2.0>(){<V2> = <R1#1<=R1<=9;#>;<< <V2> / 2;return <V2>;}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<O1>.<V1> = <R2#11<=R2<=19;#>;
  << <O2>.<O1>.<V1>;
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 


# 2401
OOP.Object.Variable.Public.Wrt Composer
>
{<C1>{
public:
  <T1#signedtype#><F1.1.0>(){>> <V1>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T1><F1>(){<V2> = <O1>.<F1.1.0>();<V2> = <V2> * <V2>;<< <V2>;}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<V1> = <R1#11<=R1<=19;#>;
  << <O2>.<F1>();
}}
>
Input: "<R2#6<=R2<=9;#>\n<R3#1<=R3<=5;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member wrt composing object by client - 2425
// Object.Variable.Protected.Wrt Composer

# 2425
OOP.Object.Variable.Protected.Wrt Composer
>
{<C1>{
public:
  <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>;<V1> = <V1> * 2;return <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public: 
   <T0><F2.2.1>( <T1><V3> ){<V2> = <V3> / 2;<V2> = <V2> * 10;<< <V2>;}
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <T1><V4> = <R2#11<=R2<=19;#>;
  <O2>.<O1>.<V1> = <V4>;
  << <V4>;
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

# 2426
OOP.Object.Variable.Protected.Wrt Composer
>
{<C1>{
public:
  <T1#signedtype#><F1.1.0>(){>> <V1>;<V1> = <V1> * 2;return <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2>{
public: 
  <T0><F1>( <T1><V2> ){<< <V2>; << <O1>.<F1.1.0>(); << <V2> + <O1>.<F1.1.0>();}
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();    >> <O2>.<V1>;
}}
>
Input: "<R2#6<=R2<=9;#>\n<R3#1<=R3<=5;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member wrt composing object by client - 2450
// Object.Variable.Private.Wrt Composer

# 2450
OOP.Object.Variable.Private.Wrt Composer
>
{<C1>{
public:
  <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;return <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2>{
public: 
  <T0><F1>(){<T1><V2> = <O1>.<F1.1.0>();<V2> = <V2> * 10;<< <V2>;}
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <T1><V4>;
  <C2><O2> = <F2.0.0>();    >> <O2>.<O1>.<V1>;   >> <V4>;
  << <V4>;
}}
>
Input: "<R2#6<=R2<=9;#>\n<R3#R3 = R2 * 10;#>\n<R4#R4 = R2 + 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

# 2451
OOP.Object.Variable.Private.Wrt Composer
>
{<C1>{
public:
  <T1#signedtype#><F1.1.0>(){>> <V1>;<V1> = <V1> * 10;return <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2>{
public: 
  <T0><F1>(){<< <O1>.<F1.1.0>();<< <O1>.<F1.1.0>();}
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();    >> <O2>.<V1>;
  <O2>.<F1>();
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#R3 = R1 + 1;#>\n<R4#R4 = R2 + 1;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (D) member function wrt composing object by client - 2500
// Object.Function.Public.Wrt Composer

# 2500
OOP.Object.Function.Public.Wrt Composer
?
OOP.Object.Variable.Public.By Client
>
{<C1>{
public:
   <T0><F1>(){<T1#signedtype#><V1> = <R1#1<=R1<=5;#>; << <V1>; << <V1> + 1;}
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T0><F2>(){<V2> = <R2#6<=R2<=9;#>;<< <V2>;<< <V2> - 1;}
  <C1><O1>;
protected:
private: 
  <T1><V2>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<O1>.<F1>();
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

# 2501
OOP.Object.Function.Public.Wrt Composer
>
{<C1>{
public:
  <T0><F1>(){<T1#signedtype#><V1>; >> <V1>;<< <V1>;<< <V1> * 10;}
protected: 
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <T0><F2>(){<O1>.<F1>();<O1>.<F1>();}
  <C1><O1>;
protected:
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<F1>();
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#1<=R3<=9;#>\n<R4#R4 = R2 * 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) member function wrt composing object by client - 2525
// Object.Function.Protected.Wrt Composer

# 2525
OOP.Object.Function.Protected.Wrt Composer
>
{<C1>{
public:
protected: 
   <T1#signedtype#><F1>(){<T1><V1> = <R1#1<=R1<=9;#>; if( <V1> % 2 == 0 ) << <V1>; else << <V1> - 1;}
private:
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
  <T0><F2>(){<T1><V2> = <O1>.<F1>();if( <V2> > 5 ) << <V2> - 1;else << <V2> + 1;}
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  << <O2>.<O1>.<F1>();
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

# 2526
OOP.Object.Function.Protected.Wrt Composer
>
{<C1>{
public:
protected: 
  <T0><F1>(){ do{ >> <V1>; }while( <V1> % 2 == 0 ); << <V1>;}
private:
  <T1#signedtype#><V1>;
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
  <T0><F2>(){<T1><V2>; do{ >> <V2>; }while( <V2> < 10 ); << <V2>;}
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<F1>();
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function wrt composing object by client - 2550
// Object.Function.Private.Wrt Composer
// 

# 2550
OOP.Object.Function.Private.Wrt Composer
>
{<C1>{
public:
   <T1#signedtype#><V1>;
protected: 
private:
  <T0><F1>( <T1><V2> ){if( <V2> >= 0 ) {<V1> = <V2>;} else <V1> = 0;<< <V1>;}
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
  <T0><F2>( <T1><V4> ){ <V3> = <V4>; if( <V4> <= 5 ){ <V4> = <V4> * 2;} <V1> = <V4>; << <V3>;}
private: 
  <T1><V3>
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<O1>.<F1>( <R1#1<=R1<=9;#> );
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

# 2551
OOP.Object.Function.Private.Wrt Composer
>
{<C1>{
public:
  <T1#signedtype#><V1>;
protected: 
private:
  <T0><F1>(){do{ >> <V1>;} while( <V1> < 10 ); << <V1>;}
}
<C2>{
public: 
  <T0><F2.0.0>(){<O1> = <F1.0.0>();}
  <C1><O1>;
protected:
  <T1><F2>( <T1><V2> ){<T1><V3>; do{ >> <V3>;} while( <V3> < <V2> );return <V3>;}
private: 
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>(); 
  <O2>.<F1>();
}}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Object is returned by a function, which is then accessed - 2600
// Object.Returned.By Composer  // Calling selector/mutator w.r.t object returned by Composer
// This learning objective is about chaining dot operator more than anything else..

# 2600
OOP.Object.Returned.By Composer
?
OOP.Object.{Constructor.By Client,Selector.By Client,Variable.Protected.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=4;#>;}
   <T1#signedtype#><F1.1.0>(){ return <V1>; }
protected: 
   <T1><V1>;
private:
}
<C2>{
public:
   <T0><F2.0.0>(){<O1>=<F1.0.0>();<V2> = <R2#5<=R2<=9;#>;}
   <C1><F1>(){ return <O1>; }
protected: 
   <T1><V2>;
   <C1><O1>;
private:
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();
  << <O2>.<F1>().<F1.1.0>();
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 


# 2601
OOP.Object.Returned.By Composer
?
OOP.Object.{Constructor.By Client,Mutator.By Client,Variable.Private.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=4;#>;}
   <T0><F1.1.1>(<T1><V3>){<V1> = <V3>; << <V1>;}
protected: 
private:
   <T1#signedtype#><V1>;
}
<C2>{
public:
   <T0><F2.0.0>(){<O1>=<F1.0.0>();<V2> = <R2#5<=R2<=9;#>;}
   <C1><F1>(){ return <O1>; }
protected: 
private:
   <T1><V2>;
   <C1><O1>;
}
<T0><F0>(){
  <C2><O2> = <F2.0.0>();
  <O2>.<F1>().<F1.1.1>( <R3#11<=R3<=14;#> );
}}
>
Type: debug_output
Languages: C++ 
Hardness: 10 



// =================================================================================
// // PUBLIC INHERITANCE
// // ---------------------------------------------------------------------------------
// // Called in inheritor function, which is in turn called by client
// ---------------------------------------------------------------------------------
// // Accessing public (B) data member by inheriting class - 3000
// Object.Variable.Public.By Inheritor

# 3000
OOP.Object.Variable.Public.By Inheritor
>
{<C1>{
public:
   <T1#signedtype#><F1>(){<V1>=<R1#0<=R1<=5;#>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(){<V1>=<R2#6<=R2<=9;#>;<< <V1>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<F2>();}
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (B) data member by inheriting class - 3025
// Object.Variable.Protected.By Inheritor

# 3025
OOP.Object.Variable.Protected.By Inheritor
>
{<C1>{
public:
   <T1#signedtype#><F1>(){<V1>=<R4#0<=R4<=9;#>;return <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(){>> <V1>;<V1> = <V1> + 1;<< <V1>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<F2>();}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 + 1;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member by inheriting class - 3050
// Object.Variable.Private.By Inheritor

# 3050
OOP.Object.Variable.Private.By Inheritor
>
{<C1>{
public:
   <T1#signedtype#><F1>(){<V1>=<R1#0<=R1<=5;#>;return <V1>;}
protected: 
private:
   <T1><V1>;
}
<C2> : public <C1>{
public: 
  <T0><F2>(){<T1><V2> = <R2#6<=R2<=9;#>;<< <V2>;<V1> = <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<F2>();}
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (B) member function by inheriting class - 3100
// Object.Function.Protected.By Inheritor

# 3100
OOP.Object.Function.Protected.By Inheritor
>
{<C1>{
public:
protected: 
   <T0><F1>(){<T1#signedtype#><V1>;>> <V1>;<< <V1>;}
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(<T1><V3>){<< <V3>;<F1>();}
protected: 
private: 
}
<T0><F0>(){
  <T1><V2> = <R4#1<=R4<=9;#>;
  <C2><O1> = <F2.0.0>();
  <O1>.<F2>( <V2> );}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 + 1;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function by inheriting class - 3125
// Object.Function.Private.By Inheritor

# 3125
OOP.Object.Function.Private.By Inheritor
>
{<C1>{
public:
protected: 
private:
   <T0><F1>(<T1#signedtype#><V1>){<V1> = <V1> * 2;<< <V1>;}
}
<C2> : public <C1>{
public: 
  <T0><F2>(){<T1><V2> = <R1#0<=R1<=9;#>;<< <V2>;<F1>(<V2>);}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<F2>();}
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (B) data member wrt inheriting object by client - 3200
// Object.Variable.Public.Wrt Inheritor

# 3200
OOP.Object.Variable.Public.Wrt Inheritor
>
{<C1>{
public:
   <T1#signedtype#><F1>(){<T1><V3>;>> <V3>;<< <V3>;return <V3>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(<T1><V2>){<< <V2>;<V2> = <V2> + 1;<< <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <T1><V3> = <R4#11<=R4<=19;#>;
  <C2><O1> = <F2.0.0>();
  <O1>.<V1> = <V3>;
  << <V3>;}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 + 1;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member wrt inheriting object by client - 3225
// Object.Variable.Protected.Wrt Inheritor

# 3225
OOP.Object.Variable.Protected.Wrt Inheritor
>
{<C1>{
public:
   <T1#signedtype#><F1>(){>> <V1>;<< <V1>;return <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(<T1><V2>){<V1> = <V2>;<V2> = <V2> / 10;<< <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<V1> = <R1>;
  <O1>.<F2>(<R3>);}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 + 1;#>\n<R3#R3 = R1 * 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member wrt inheriting object by client - 3250
// Object.Variable.Private.Wrt Inheritor

# 3250
OOP.Object.Variable.Private.Wrt Inheritor
>
{<C1>{
public:
   <T0><F1>(<T1#signedtype#><V3>){if(<V3> > 0) <V1> = <V3>; else <V1> = 0;}
protected: 
private:
   <T1><V1>;
}
<C2> : public <C1>{
public: 
  <T1><F2>(){<T1><V2>;>> <V2>;return <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();   >> <O1>.<V1>;
  << <O1>.<F2>();}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 * 10;#>\n<R3#R3 = R1 + 1;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (B) member function wrt inheriting object by client - 3300
// Object.Function.Public.Wrt Inheritor

# 3300
OOP.Object.Function.Public.Wrt Inheritor
>
{<C1>{
public:
   <T0><F1>(){<T1#signedtype#><V1> = <R3>; << <V1>;}
protected: 
private:
}
<C2> : public <C1>{
public: 
  <T1><F2>(){<T1><V2>;>> <V2>;return <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <T1><V3> = <R2>;
  <C2><O1> = <F2.0.0>();
  <O1>.<F1>();
  << <V3>;}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 * 10;#>\n<R3#R3 = R1 * 2;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) member function wrt inheriting object by client - 3325
// Object.Function.Protected.Wrt Inheritor

# 3325
OOP.Object.Function.Protected.Wrt Inheritor
>
{<C1>{
public:
protected: 
   <T1#signedtype#><F1>(){<T1><V1>;>> <V1>; return <V1>;}
private:
}
<C2> : public <C1>{
public: 
  <T0><F2>(){<T1><V2>;<V2> = <F1>() + <F1>();<< <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  << <O1>.<F1>();}
}
>
Input: "<R1#0<=R1<=9;#>\n<R2#R2 = R1 * 10;#>\n<R3#R3 = R1 * 2;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function wrt inheriting object by client - 3350
// Object.Function.Private.Wrt Inheritor

# 3350
OOP.Object.Function.Private.Wrt Inheritor
>
{<C1>{
public:
protected: 
private:
   <T0><F1>(<T1#signedtype#><V1>){<< <V1> - 1; << <V1>; << <V1> + 1;}
}
<C2> : public <C1>{
public: 
  <T0><F2>(<T1><V2>){<< <V2> / 2; << <V2> % 2;}
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <O1>.<F1>( <R1#1<=R1<=8;#> );
  <O1>.<F2>( <R1> );}
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of constructor code (B) when inheriting class's constructor calls it - 3400
// Object.Constructor.Inheritor.Coopted

# 3400
OOP.Object.Constructor.Inheritor.Coopted
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#6<=R1<=9;#>;<< <V1>;}
   <T1#signedtype#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();<V2> = <R2#1<=R2<=5;#>;<< <V2>;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <T1><V3> = <R3#11<=R3<=19;#>;
  << <V3>;
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of constructor code (B) when inheriting class's constructor does not call it - 3425
// Object.Constructor.Inheritor.Not Coopted

# 3425
OOP.Object.Constructor.Inheritor.Not Coopted
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#6<=R1<=9;#>;<< <V1>;<< <V1> - 1;}
   <T1#signedtype#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<V2> = <R2#1<=R2<=5;#>;<< <V2>;<< <V2> + 1;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <T1><V3> = <R3#11<=R3<=19;#>;
  <C2><O1> = <F2.0.0>();
  << <V3>;
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Constructor is called with arguments, some of which are passed to base class - 3450
// Object.Initialization.Inherited object

# 3450
OOP.Object.Initialization.Inherited object
?
OOP.Object.{Initialization.Basic object,Variable.Protected.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V4>){<V1> = <V4>;<< <V1>;}
protected: 
   <T1><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(<T1><V5>, <T1><V6>){<F1.0.0>(<V5>);<V2> = <V6>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <T1><V3> = <R1#1<=R1<=4;#>;
  <T1><V7> = <R2#5<=R2<=9;#>;
  <C2><O1> = <F2.0.0>( <V3>, <V7> );
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

# 3451
OOP.Object.Initialization.Inherited object
?
OOP.Object.{Initialization.Basic object,Variable.Private.By Object Function}
>
{<C1>{
public:
   <T0><F1.0.0>(<T1#signedtype#><V4>){<V1> = <V4>;<V4> = <V4> + 1;<< <V4>;}
protected: 
private:
   <T1><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(<T1><V5>, <T1><V6>){<F1.0.0>(<V5>);<V2> = <V6>;<V6> = <V6> - 1;<< <V6>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <T1><V3>;   >> <V3>;
  <T1><V7>;   >> <V7>;
  <C2><O1> = <F2.0.0>( <V3>, <V7> );
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// =================================================================================
// // In each problem, call the overridden function wrt BOTH base and derived class object
// // Execution of selectors (B) by inheriting class 
// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by client wrt inheriting object which overrides it, calls it and behavior is polymorphic - 3500
// Object.Selector.Inheritor.Overridden.Coopted.Polymorphic

# 3500
OOP.Object.Selector.Inheritor.Overridden.Coopted.Polymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   virtual <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><F1.1.0>(){<T1><V2> = <C*>.<F1.1.0>();<V2> = <V2> * 10;<< <V2>;return <V2>;}
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3> = <O1>.<F1.1.0>();
  << <V3>;
  <C1><O2> = <F2.0.0>();
  <V3> = <O2>.<F1.1.0>();
  << <V3>;
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by client wrt inheriting object which overrides it, does not call it and behavior is polymorphic - 3525
// Object.Selector.Inheritor.Overridden.Not Coopted.Polymorphic

# 3525
OOP.Object.Selector.Inheritor.Overridden.Not Coopted.Polymorphic
?
OOP.Object.{Variable.Public.{By Inheritor,By Object Function},Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   virtual <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><F1.1.0>(){<V1> = <R2#6<=R2<=9;#>;<< <V1>;return <V1>;}
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V2> = <O1>.<F1.1.0>();
  << <V2>;
  <C1><O2> = <F2.0.0>();
  <V2> = <O2>.<F1.1.0>();
  << <V2>;
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by client wrt inheriting object which does not override - 3550
// Object.Selector.Inheritor.Not Overridden

# 3550
OOP.Object.Selector.Inheritor.Not Overridden
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   virtual <T1#signedtype#><F1.1.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><F1>(<T1><V3>){<V1> = <V3> + <R2#6<=R2<=9;#>;<< <V1>;return <V1>;}
protected: 
private: 

}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <T1><V2> = <O1>.<F1.1.0>();
  << <V2>;
  <C1><O2> = <F1.0.0>();
  <V2> = <O2>.<F1.1.0>();
  << <V2>;
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by client wrt inheriting object which overrides it, calls it, and behavior is not polymorphic (C++ only) - 3575
// Object.Selector.Inheritor.Overridden.Coopted.NonPolymorphic

# 3575
OOP.Object.Selector.Inheritor.Overridden.Coopted.NonPolymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){>> <V1>;<< <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><F1.1.0>(){<T1><V2> = <C*>.<F1.1.0>();>> <V3>;<< <V3>;  return <V3> - <V2>;}
   <T1><V3>;
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F2.0.0>();
  << <O1>.<F1.1.0>();
  <C1><O2> = <F1.0.0>();
  << <O2>.<F1.1.0>();
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of selectors (B) by client wrt inheriting object which overrides it, does not call it, and behavior is not polymorphic (C++ only) - 3600
// Object.Selector.Inheritor.Overridden.Not Coopted.NonPolymorphic

# 3600
OOP.Object.Selector.Inheritor.Overridden.Not Coopted.NonPolymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   <T1#signedtype#><F1.1.0>(){>> <V1>; if( <V1> < <R2> ){ <V1> = <V1> + 1; } << <V1>;return <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><F1.1.0>(){>> <V2>; if( <V2> > <R1> ){ <V2> = <V2> - 1; } << <V2>;return <V2>;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F2.0.0>();
  << <O1>.<F1.1.0>();
  <C1><O2> = <F1.0.0>();
  << <O2>.<F1.1.0>();
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// =================================================================================
// // In each problem, call the overridden function wrt both base and derived class object
// // Execution of mutators (B) by inheriting class 
// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by client wrt inheriting object which overrides it, calls it and behavior is polymorphic - 3700
// Object.Mutator.Inheritor.Overridden.Coopted.Polymorphic

# 3700
OOP.Object.Mutator.Inheritor.Overridden.Coopted.Polymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   virtual <T0><F1.1.1>(<T1#signedtype#><V2>){<V1> = <V2>;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F1.1.1>(<T1><V3>){<C*>.<F1.1.1>(<V3>);<V3> = <V3> * 10; << <V3>;}
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <R1#1<=R1<=5;#> );
  <C1><O2> = <F2.0.0>();
  <O2>.<F1.1.1>( <R2#6<=R2<=9;#> );
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by client wrt inheriting object which overrides it, does not call it and behavior is polymorphic - 3725
// Object.Mutator.Inheritor.Overridden.Not Coopted.Polymorphic

# 3725
OOP.Object.Mutator.Inheritor.Overridden.Not Coopted.Polymorphic
?
OOP.Object.{Variable.Public.{By Object Function,By Inheritor},Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   virtual <T0><F1.1.1>(<T1#signedtype#><V2>){<V1> = <V2> + 1;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F1.1.1>(<T1><V3>){<V1> = <V3> - 1; << <V1>;}
protected: 
private: 

}
<T0><F0>(){
  <C1><O1> = <F2.0.0>();
  <O1>.<F1.1.1>( <R1#1<=R1<=5;#> );
  <C1><O2> = <F1.0.0>();
  <O2>.<F1.1.1>( <R2#6<=R2<=9;#> );
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by client wrt inheriting object which does not override - 3750
// Object.Mutator.Inheritor.Not Overridden

# 3750
OOP.Object.Mutator.Inheritor.Not Overridden
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   virtual <T0><F1.1.1>(<T1#signedtype#><V2>){<V1> = <V2> + 10;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F1>(<T1><V3>,<T1><V4>){<V1> = <V3> + <V4>; << <V1>;}
protected: 
private: 

}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <T1><V4> = <R1#1<=R1<=5;#>;
  <O1>.<F1.1.1>( <V4> );
  <C1><O2> = <F1.0.0>();
  <V4> = <R2#6<=R2<=9;#>;
  <O2>.<F1.1.1>( <V4> );
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by client wrt inheriting object which overrides it, calls it, and behavior is not polymorphic (C++ only) - 3775
// Object.Mutator.Inheritor.Overridden.Coopted.NonPolymorphic

# 3775
OOP.Object.Mutator.Inheritor.Overridden.Coopted.NonPolymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V2>){<V2> = <V2> * 10;<V1> = <V2>;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F1.1.1>(<T1><V3>){<V3> = <V3> + 10;<C*>.<F1.1.1>(<V3>);<< <V3>;}
protected: 
private: 
}
<T0><F0>(){
  <T1><V4>;
  <C1><O1> = <F1.0.0>();   >> <V4>;
  <O1>.<F1.1.1>( <V4> );
  <C1><O2> = <F2.0.0>();   >> <V4>;
  <O2>.<F1.1.1>( <V4> );
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Execution of mutators (B) by client wrt inheriting object which overrides it, does not call it, and behavior is not polymorphic (C++ only) - 3800
// Object.Mutator.Inheritor.Overridden.Not Coopted.NonPolymorphic

# 3800
OOP.Object.Mutator.Inheritor.Overridden.Not Coopted.NonPolymorphic
?
OOP.Object.{Variable.Public.By Object Function,Assignment.Aggregate.Assigning derived object to base variable}
>
{<C1>{
public:
   <T0><F1.1.1>(<T1#signedtype#><V2>){<V1> = <V2> + 1;<< <V1>;}
   <T1><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F1.1.1>(<T1><V3>){<< <V3>; <V1> = <V3> - 1; << <V1>;}
protected: 
private: 

}
<T0><F0>(){
  <T1><V4>;   >> <V4>;
  <C1><O1> = <F1.0.0>();
  <O1>.<F1.1.1>( <V4> );
  <C1><O2> = <F2.0.0>();
  <O2>.<F1.1.1>( <V4> );
}
>
Input: "<R1#1<=R1<=8;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 


// ---------------------------------------------------------------------------------
// // Execution of destructor code (B) when inheriting class's destructor calls it - 3850
// Object.Destructor.By Inheritor

# 3850
OOP.Object.Destructor.By Inheritor
?
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.1>(){<V1> = <R1#6<=R1<=9;#>;<< <V1>;}
   <T1#signedtype#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.1>(){<F1.0.1>();<V2> = <R2#1<=R2<=5;#>;<< <V2>;}
   <T1><V2>;
protected: 
private: 

}
<T0><F0>(){
  <C2><O1> = <F2.0.0>();
  <T1><V3> = <R3#11<=R3<=19;#>;
  << <V3>;
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 
// ---------------------------------------------------------------------------------
// // Assigning base class object to derived class variable - 3900
// Object.Assignment.Aggregate.Assigning base object to derived variable

# 3900
OOP.Object.Assignment.Aggregate.Assigning base object to derived variable
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
   <T1#signedtype#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();<V2> = R2#6<=R2<=9;#>;<< <V2>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C2><O1> = <F1.0.0>();
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

# 3901
OOP.Object.Assignment.Aggregate.Assigning base object to derived variable
>
{<C1>{
public:
   <T0><F1.0.0>(){>> <V1>;<< <V1>;}
protected: 
   <T1#signedtype#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();>> <V2>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C2><O1> = <F1.0.0>();
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Assigning derived class object to base class variable - 3925
// Object.Assignment.Aggregate.Assigning derived object to base variable

# 3925
OOP.Object.Assignment.Aggregate.Assigning derived object to base variable
?
OOP.Object.{Variable.Protected.By Object Function,Constructor.By Client,Constructor.Inheritor.Coopted}
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
   <T1#signedtype#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();<V2> = R2#6<=R2<=9;#>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C1><O1> = <F2.0.0>();
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

# 3926
OOP.Object.Assignment.Aggregate.Assigning derived object to base variable
?
OOP.Object.{Variable.Private.By Object Function,Constructor.By Client,Constructor.Inheritor.Coopted}
>
{<C1>{
public:
   <T0><F1.0.0>(){>> <V1>;<< <V1>;}
protected: 
private:
   <T1#signedtype#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();>> <V2>;<< <V2>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F2.0.0>();
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Assigning object of one derived class to variable of another derived class - 3950
// Object.Assignment.Aggregate.Assigning derived object to different derived variable


# 3950
OOP.Object.Assignment.Aggregate.Assigning derived object to different derived variable
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = <R1#1<=R1<=5;#>;<< <V1>;}
protected: 
private:
   <T1#signedtype#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();<V2> = R2#6<=R2<=9;#>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<C3> : public <C1>{
public: 
   <T0><F3.0.0>(){<F1.0.0>();<V3> = R3#11<=R3<=14;#>;<< <V3>;}
   <T1><V3>;
protected: 
private: 
}
<T0><F0>(){
  <C2><O1> = <C3>.<F3.0.0>();
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

# 3951
OOP.Object.Assignment.Aggregate.Assigning derived object to different derived variable
>
{<C1>{
public:
   <T0><F1.0.0>(){>> <V1>;<< <V1>;}
   <T1#signedtype#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T0><F2.0.0>(){<F1.0.0>();>> <V2>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<C3> : public <C1>{
public: 
   <T0><F3.0.0>(){<F1.0.0>();>> <V3>;<< <V3>;}
protected: 
private: 
   <T1><V3>;
}
<T0><F0>(){
  <C3><O1> = <F2.0.0>();
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// =================================================================================
// // Called in ancestor function, which is in turn called by client
// // Accessing public (B) data member by ancestral class - 4000
// Object.Variable.Public.By Ancestor

# 4000
OOP.Object.Variable.Public.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){<V1>=<R1#1<=R1<=4;#>;<< <V1>; <V2>=<R2#5<=R2<=9;#>;}
   <T1#signedtype#><V1>;
protected: 
private:
}
<C2> : public <C1>{
public: 
   <T1><V2>;
protected: 
private: 
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (B) data member by ancestral class - 4025
// Object.Variable.Protected.By Ancestor

# 4025
OOP.Object.Variable.Protected.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>; >> <V2>; << <V1>;}
protected: 
   <T1#signedtype#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F2>(){>> <V2>;<< <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member by ancestral class - 4050
// Object.Variable.Private.By Ancestor

# 4050
OOP.Object.Variable.Private.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>; <V2> = <V1>; << <V1>;}
protected: 
private:
   <T1#signedtype#><V1>;
}
<C2> : public <C1>{
public: 
protected: 
   <T0><F2>(){>> <V2>;<T1><V3>; >> <V3>;<< <V3> - <V2>;}
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Called in inheritor function, which is in turn called by client
// // Accessing public (B) member function by ancestral class - 4100
// Object.Function.Public.By Ancestor

# 4100
OOP.Object.Function.Public.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>;<< <V1>; <F2>();}
protected: 
   <T1#signedtype#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T0><F2>(){>> <V2>; << <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (B) member function by ancestral class - 4125
// Object.Function.Protected.By Ancestor

# 4125
OOP.Object.Function.Protected.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;<V1> = <V1> * 10; <F2.2.1>(<V1>);}
protected: 
private:
   <T1#signedtype#><V1>;
}
<C2> : public <C1>{
public: 
protected: 
   <T0><F2.2.1>(<T1><V3>){<V2> = <V3>; << <V2>;}
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function by ancestral class - 4150
// Object.Function.Private.By Ancestor

# 4150
OOP.Object.Function.Private.By Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>; << <F2.2.0>(); << <V1>;}
protected: 
   <T1#signedtype#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T1><V2>;
protected: 
private: 
   <T1><F2.2.0>(){>> <V2>;<< <V2>;return <V2>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (B) data member wrt ancestral object by client - 4200
// Object.Variable.Public.Wrt Ancestor

# 4200
OOP.Object.Variable.Public.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){<V1>=<R1#1<=R1<=4;#>;<< <V1>;}
protected: 
   <T1#signedtype#><V1>;
private:
}
<C2> : public <C1>{
public: 
   <T1><V2>;
   <T1><F2.2.0>(){return <V2>;}
protected: 
private: 
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V3> = <R2#5<=R2<=9;#>;
  <O1>.<V2> = <V3>;
  << <V3>;}
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) data member wrt ancestral object by client - 4225
// Object.Variable.Protected.Wrt Ancestor

# 4225
OOP.Object.Variable.Protected.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>; <V1> = <V1> + 1; << <V1>;}
protected: 
private:
   <T1#signedtype#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2>(){>> <V2>; <V2> = <V2> - 1; << <V2>;}
protected: 
   <T1><V2>;
private: 
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();   >> <O1>.<V2>;
  <O1>.<F1>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) data member wrt ancestral object by client - 4250
// Object.Variable.Private.Wrt Ancestor

# 4250
OOP.Object.Variable.Private.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){>> <V1>; <V1> = <V1> * 10; << <V1>;}
protected: 
   <T1#signedtype#><V1>;
private:
}
<C2> : public <C1>{
public: 
protected: 
   <T0><F2>(){>> <V2>; <V2> = <V2> * 2; << <V2>;}
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F1>();
  <O1>.<V2> = <R4#16<=R4<=19;#>;}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing public (B) member function wrt ancestral object by client - 4300
// Object.Function.Public.Wrt Ancestor

# 4300
OOP.Object.Function.Public.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R4#16<=R4<=19;#>;<< <V1>;}
protected: 
private:
   <T1#signedtype#><V1>;
}
<C2> : public <C1>{
public: 
   <T0><F2>(){>> <V2>; << <V2>;}
protected: 
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <O1>.<F2>();}
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing protected (D) member function wrt ancestral object by client - 4325
// Object.Function.Protected.Wrt Ancestor

# 4325
OOP.Object.Function.Protected.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){<V1> = <R1#1<=R1<=9;#>;<< <V1>;}
protected: 
private:
   <T1#signedtype#><V1>;
}
<C2> : public <C1>{
public: 
protected: 
   <T0><F2.2.1>(<T1><V3>){<V2> = <V3>; << <V2>;}
private: 
   <T1><V2>;
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  <T1><V4> = <R2#6<=R2<=9;#>;
  <O1>.<F2.2.1>(<V4>);}
}
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------
// // Accessing private (D) member function wrt ancestral object by client - 4350
// Object.Function.Private.Wrt Ancestor

# 4350
OOP.Object.Function.Private.Wrt Ancestor
>
{<C1>{
public:
   <T0><F1>(){<T1#signedtype#><V3>; >> <V1>; >> <V3>; if( <V1> < <V3> ){ << <V1>; }else << <V3>;}
protected: 
private:
   <T1><V1>;
}
<C2> : public <C1>{
public: 
protected: 
   <T1><V2>;
private: 
   <T1><F2.2.0>(){>> <V2>;<< <V2>;return <V2>;}
}
<T0><F0>(){
  <C1><O1> = <F1.0.0>();
  << <O1>.<F2.2.0>(); }
}
>
Input: "<R1#1<=R1<=5;#>\n<R2#6<=R2<=9;#>\n<R3#11<=R3<=15;#>\n<R4#16<=R4<=19;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10 

// ---------------------------------------------------------------------------------

// Used solely for testing code 
# 9000
OOP.Object.Variable.Public.By Object Function
>
{<C1>{
public:
   <T0><F1.0.0>(){<V1> = 29; << <V1>;}
   <T1#signedtype#><F1.1.0>(){return <V1>;}
   <T0><F1.1.1>(<T1><V2>){if(<V2> >= 0){ <V1>=<V2>;} else {<V1> = 1;}}
   static <T0><F4>(<T1><V2>){<< <V2>;}
   <T0><F1.0.1>(){<< <V1>;}

   <T1><V1>;
   static <T1><V3>;
protected: 
//   <T1><V4>[5];
private:
   <T1><V5>;
}
<C2>{
public:
   <T1><F3>(){return <V6>;}
   <T0><F2.0.0>(){<V6> = 51; << <V6>;}
   <T1><V6>;
private:
   <C1><O2>;
}
<C3>{
public:
   <C1><O4>;
   <T0><F3.0.0>(){<T1><V6> = 51; << <V6>;}
}
<T0><F0>(){
  <C1><O1> = <O1>.<F1.0.0>();
  <T1><V7>=13;   >> <V7>;
  <O1>.<V1> = <R1#0<=R1<=9;#>;
  << <O1>.<F1.1.0>();
  <C2><O3> = <O3>.<F2.0.0>();
// Following statement leads to stack overflow - why?
//  >> <O3>.<O2>.<V1>;  
  <O3>.<V6> = <R2#0<=R2<=9;#>;
  << <O3>.<F3>();
  <C3><O5> = <O5>.<F3.0.0>();
}}
>
Input: "<R3#0<=R3<=8;#>\n<R4#R4 = R3 + 10;#>\n<R5#R5 = R3 * 10;#>"
>
Type: debug_output
Languages: C++ 
Hardness: 10