《继承与派生》PPT课件

单击此处编辑母版标题样式,单击此处编辑母版文本样式,第二级,第三级,第四级,第五级,*,第四章 继承与派生,4.1继承的层次关系,1 继承的概念,一个类的数据成员和成员函数，有些是类本身自己定义的，有一些是,可继承,的或通过,模板,生成的。,所谓,继承,（inheritance）就是利用已有的数据类型定义出,新的数据类型,。利用类的“继承”，就可以将原来的程序代码重复使用，从而减少了程序代码的冗余度，符合软件重用的目标。所以说，继承是面向对象程序设计的一个重要机制。另外，在C+中扩充派生类成员的方法是非常灵活的。在继承关系中，称被继承的类为,基类（base class）（或父类）,，而把通过继承关系定义出来的新类称为,派生类（derived class）（子类,）。由此可见，派生类既可以对基类的性质进行扩展，又可以进行限制，从而得到更加灵活、更加适用的可重用模块，大大缩短程序的开发时间。,4.1派生类,在基类的基础上定义其派生类的定义形式为：,class 派生类名：,访问方式,基类名, 派生类中的新成员 ,其中：,（1）,派生类名,由用户自己命名；,（2）,访问方式,即继承方式，可以为,public,或,private,，,默认,为,private,方式。访问方式为,public,方式时，这种继承称为,公有继承,，而访问方式为private方式时，称为,私有继承,；,（3）,基类名,必须是程序中一个已有的类。,（4）在冒号“：”后的部分告诉系统，这个派生类是从哪个基类派生的，以及在派生时的继承方式。,（5）大括号内的部分是派生类中新定义的成员。,class x, int a ;,public:,x() a=12;,int get() return a;,void print(), cout a endl; ;,class y:x,/私有继承, int b;,/,public :,void make(), b=get()+10;,/调用了基类的成员,void print(), x:print(); cout b endl; ;,void main(),class,x x1;,class,y y1; y1.make();,y1.get();,/错误,x1.get();,/对,y1.print();,/输出 12 22,例41：,4.2.2 派生类的生成过程,派生类的生成过程三个步骤：吸收基类成员、改造基类成员、添加派生类新成员。,1、吸收基类成员,不吸收构造函数和析构函数,2、改造基类成员,继承方式控制,定义同名成员屏蔽基类成员（见例4021）,3、添加新成员,增加新的数据成员；,增加新的成员函数；（构造和析构）,4.3访问权限控制,公有继承,按,public,方式继承（即公有继承）时，基类中的,公有成员,和,保护成员,在派生类中不变。基类中的私有成员在派生类中仍是不可访问的,【例4031】#include iostream.h,class base, int x1,x2;,public:,void assign(int p1,int p2) x1=p1;x2=p2;,int inc1() x1+; return x1;,int inc2() x2+; return x2;,void display() cout x1 x2 endl ; ;,class,derive1:base, int x3;,public:,derive1(int p3) x3=p3;,void assign(int p1,int p2), base:assign(p1,p2);,int inc1(), return base:inc1();,int inc2(), return base:inc2();,int inc3(), x3+;return x3;,void display(), base:display();,cout x3 endl; ;,class,derive2:,public,base, int x4;,public:,derive2(int p4) x4=p4;,int inc1(), int temp=base:inc1();,temp=base:inc1();,temp=base:inc1();,return base:inc1(); ,int inc4(), x4+;return x4;,void display(), base:display();,cout x4 endl; ;,int main(int argc, char* argv), base p;,p.assign(-2,-2);,cout base-:n;,p.display() ;,/ -2 -2,derive1 d1(-4);,d1.assign(10,10);,cout nderive1-:n;,d1.display();,/ x1=10 x2=10 /x3=-4,d1.inc1();,d1.inc2();,d1.inc3();,cout nderive1-2-:n;,例4-03-2 #include stdio.h,class x,protected,:,int i,j;,public,:,x(int i,int j) x:i =i;x:j=j;,void print() printf(%d %dn,i,j);,;,class y:,public,x, int k;,public,:,y(int i,int j):x(i,j) k=i*j;,void print(), printf(“%d %d %dn”,i,j,k);,/ i,j 在类y中是保护段中的成员,;,class z:y,public,:,z(int i,int j):y(i,j) ,void print1(), printf(“%d %dn”,i,j);,/i,j 在类z中是私有段中的成员,void print() y:print();,;,void main(),class,z z1(10,20);,class,y y1(30,40);,y1.print();,/ i=30 j=40 k=1200,z1.print();,/ i=10,j=20,z1.print1();,/ i=10,j=20,私有继承,按,private,方式继承（即私有继承）时，基类中的公有成员和保护成员在派生类中皆变为,私有成员,。这些私有成员只能被,派生类,的成员函数访问，而派生类的,使用者,无权访问。（例4-02-2）,保护继承,在派生类中，基类的公有成员和保护成员作为派生类的保护成员，派生类的成员可以直接访问他们，而派生类的成员无法访问基类的私有成员，在类外部，派生类的对象无法访问基类的所有成员。,无论哪种继承方式，基类的,私有成员,均不能继承。这与私有成员的定义是一致的，符合数据封装的思想。,在公有继承方式下，基类的公有成员和保护成员被继承为派生类成员时，其访问属性不变。,基类,公有派生类,私有派生类,public成员,public成员,private成员,protected成员,protected成员,private成员,private成员,无法继承,无法继承,注意：私有成员,与,不可访问成员,是两个不同的概念。某个类的私有成员只能被该类的成员函数所访问，而类的不可访问成员甚至,不能,被该类自身的成员函数所访问。类的,不可访问成员,总是从某个基类派生来的，它要么是基类的私有成员，要么是基类的不可访问成员。,在C+中，可以根据需要定义,多层,的继承关系，也可以从一个基类派生出多个类，形成类的层次结构，在类的层次结构中，处于,高层的类,，表示,最一般的特征,，而处于,底层的类,，表示,更具体的特征,，在多层继承关系中，基类与派生类的关系是相对的，例如：由类A派生出类B，再由类B派生出类C，这里类B相对于类A是派生类，而相对于类C是基类，并称类C是类A的间接派生类，称类A是类C 的间接基类；而称具有直接派生关系的两个类分别为,直接派生类和直接基类。,【例4-03-3】 类Build_1是一个关于楼房数据的类。它的数据成员有posi_x、posi_y和area，分别是楼房位置的经、纬度和建筑面积。它的函数成员只有set1，用于设置数据成员posi_x、posi_y和area的值。让Build_1作为基类，再增加数据成员high、函数成员set2和disp来定义派生类Build_2。,#include ,class,Build_1,/定义基类,protected,:,int posi_x;,/ 有三个保护型的数据成员,int posi_y;,int area;,public,:,void set1(int x, int y, int a), posi_x=x; posi_y=y; area=a; ,;,/定义派生类Build_2,class,Build_2 :,public,Build_1, int height;,public,:,void set2(int h), height=h;,void disp(), coutn 经度：posi_xendl;,cout 纬度：posi_yendl;,cout 高度：heightendl;,cout 面积：areaendlendl; ,;,void main(), Build_2 obj;,/用Build_2生成对象obj,obj.set1(100,200,300);,obj.set2(400);,obj.disp();,程序执行的结果是：,经度：100,纬度：200,高度：400,面积：300,由此可见：派生类Build_2中已继承了基类Build_1中的数据成员posi_x、posi_y、area和基类中的成员函数set1，并同时增加了新的成员height和成员函数set2、disp。,4.4 派生类的构造函数和析构函数,4.4.1 派生类的构造函数,（1）派生类的数据成员和成员函数的,来源有两个，一个来源,是从基类,继承来,的数据成员和成员函数，对于继承来的数据成员，即使没有用也不能取消，只能不理会它们，但允许对一些继承来的成员函数重新定义，即在原有基类的成员函数的基础上，再增加一些操作，以完成派生类所要求的操作。,另一个来源,就是由派生类,自己定义,的数据成员和成员函数，这些成员的定义方法同一般类成员的定义方法基本一样。,（2）通过派生类的对象调用一个被重新定义过的基类的成员函数，所调用的是派生类的成员函数，此时，若想调用,基类,的成员函数，必须在成员函数名前加基类名,作用域分隔符“：”。,（3）在创建派生类的对象时，由于派生类的对象包含了基类的数据成员，因此派生类的构造函数除,初始化,其,自身定义,的数据成员外，还必须对,基类,中的数据成员进行初始化，也就是说，派生类的构造函数要,负责,调用,基类的构造函数,。所以派生类的构造函数的定义格式如下：,派生类名：派生类构造函数名（参数表）：基类构造函数名（参数表）, ,在定义对象时,构造函数的执行顺序是:,先祖先(基类),再客人(对象成员),后自己(派生类本身)。,例4-04-1 class base, int x,y;,public,:,base(int a,int b) x=a;y=b;,. ;,class derive1:base, int x2,y2;,public,:,derive1(int a,int b,int c,int d);,. ;,derive1:derive1(int a,int b,int c,int d):base(c,d), x2=a;y2=b;,（4）虽然派生类可以直接访问基类的保护数据成员，甚至在构造时初始化它们，但是一般不这么做，而是通过基类的接口（成员函数）去访问它们，初始化也是通过基类的构造函数。这样，避免了类与类之间的相互干扰。,（5）,基类的对象,只能调用,基类,的成员函数，,不能调用,派生类的成员函数。,（6）若在基类中没有定义任何构造函数，这时在派生类的构造函数的定义中,可以省略,对基类构造函数的调用，此时系统将去调用基类的,默认,构造函数。,（7）在定义派生类的对象时，系统,首先,执行,基类,的构造函数，,然后,执行派生类的构造函数。而系统,执行析构函数,的顺序恰恰相反，即,先执行,派生类的析构函数，,再执行,基类的析构函数。,4.4.2 派生类的构造函数,析造函数的执行顺序是:,先调用派生类的析构函数，再调用对象成员类的析构函数，最有调用基类的析构函数，其顺序与调用构造函数的顺序刚好相反。,【例4-04-2】,class,A,public,:,A() ,void func() coutConstructing Aendl;,A() ,void fund() coutDestructing Aendl;,;,class,B:,public,A,public,:,B() func();,void fun() func();,B() fund();,;,class,C:,public,B,public,:,C() ,void func() coutClass Cendl;,C() fund();,void fund() coutDestructing Cendl;,;,void main(),C c;,c.fun();,例4-04-3 #include stdio.h,class,data, int x;,public,:,data(int x) data:x=x; printf(class datan); ,int getx() return x; ;,class,a,class,data d1;,public,:,a(int x):d1(x) printf(class an);,int getdataa() return d1.getx(); ;,class,b:,public,a, data d2;,public,:,b(int x):a(x),d2(x) printf(class bn);,int getdatab() return d2.getx(); ;,class c:,public,b,public,:,c(int x):b(x) printf(class cn); ;,int main(int argc, char* argv), c c1(10);,printf(%d %dn,c1.getdataa(),c1.getdatab(); printf(Hello World!n);,return 0;,程序的运行结果如下： class data,class a,class data,class b,class c,10 10,Hello world!,【例4-04-4,】,本例中分别定义一个描述圆的类Ccircle和描述一个圆柱体的类Ccylinder。,#include iostream.h,class,Ccircle,/定义圆类,protected,:,double radius;,public,:,Ccircle(double radiusval), radius=radiusval; ,void setradius(double radiusval), radius=radiusval; ,double getradius() const return radius ; ,double area() const, return 3.14*radius*radius; ,;,class,Ccylinder:,public,Ccircle,/定义圆柱体类,protected,:,double height;,public,:,void Ccylinder(double radiusval, double heightval);,void setheight(double heightval), height=heightval; ,double getheight() const, return height; ,double area() const,/重新定义area()函数,/此处调用的是基类的成员函数area()，必须 加：,return 2*Ccircle:area()+2*3.14*radius*height;, ;,Ccylinder:Ccylinder(double radiusval,double heightval): Ccircle(radiusval),/调用Ccircle类的构造函数对radius初始化,/派生类Ccylinder的构造函数不但初始化自身定义的成员height，而且通过调用基类的构造函数Ccircle（）初始化从基类继承来的数据成员radius, height=heightval; ,void main(), Ccircle circle(10);,Ccylinder cylinder(2,5);,cout圆柱体表面积:cylinder.area()endl;,cout圆柱体底面积:cylinder.Ccircle:area()endl;,cout圆的面积是：circle.area();,程序的执行结果为：,圆柱体表面积：87.92,圆柱体底面积：12.56,圆的面积是：314,程序说明：,（1）求圆的面积与圆柱体的表面积的方法是不同的。因此，在派生类Ccylinder中重新定义了基类成员函数area()。在主函数中，通过基类和派生类的不同对象，,分别调用,了这两个area()函数。,（2）由于继承关系，在类Ccylinder中存在两个同名的函数area ()。其中一个是从基类Ccircle中继承过来的，另一个是在派生类Ccylinder中新定义的。这样，当通过派生类对象调用area()函数时，C+编译器将沿继承关系搜索，使用,离,调用对象,最近,的那个版本的函数。,（3）如果确实想通过Ccylinder的对象访问从基类Ccircle继承过来的area()函数，则必须使用作用域运算符,“:”,显式指明。,通过以上分析可知，C+中处理,同名函数,有以下,3,种基本方法：,（1）根据函数的,参数的特征,进行区分。即编译器根据函数的类型或个数进行区分。如：,max(int,int)max(float,float),（2）根据,类对象,进行区分。如：在上例中的main函数中，,cylinder.area()circle.area(),其中，cyclinder是Ccylinder的一个对象，circle是Ccircle的一个对象。,（3）使用,作用域运算符“:”,进行区分，如：,Ccircle:area(),以上三种区分方法都是在程序编译过程中完成的，称为,静态联编,，除此之外，C+还提供称为,动态联编,。,4.5多继承,在单一继承关系中，每个派生类最多只有一个直接基类，但它可以有多个,间接基,类。在C+中不仅支持单一继承，而且也支持多重继承，所谓,多继承,，是指派生类从,多个基类,中派生而来，使派生类继承多个基类的特征，在多重继承关系中，派生类有多个直接基类。定义多重继承类的方式如下：,class 派生类名：访问方式 基类名，访问方式 基类名, ；,其中：访问方式为,public,或,private,，功能同单一继承。,多重继承下派生类的,构造函数,必须同时负责所有基类构造函数的调用，,对于派生类构造函数的,参数个数,必须同时满足多个基类初始化的需要。所以，在多重继承下，派生类的构造函数的定义格式如下：,派生类构造函数名（参数表）：基类名1(参数表1),基类名2(参数表2)， , ,在多重继承下，系统,首先,执行各基类的构造函数，,然后再,执行派生类的构造函数，处于同一层次的,各基类构造函数的执行顺序,与,声明,派生类时所指定的各基类顺序一致，而与派生类的,构造函数定义,中所调用基类构造函数的,顺序无关,。,例4-05-1 #include iostream.h ,class,B1, int b1;,public,:,B1(int i) b1=i;,cout Constructor b1 i endl; ,void print() cout b1 endl;,;,class,B2 int b2;,public,:,B2(int i), b2=i;,cout Constructor b2 . i endl; ,void print() cout b2 endl;,;,class,B3 int b3;,public,:,B3(int i), b3=i; cout Constructor b3. i endl; ,int getb3() return b3; ;,class,A:,public,B2,public,B1, int a; B3 bb;,public,:,A(int i,int j,int k,int l):B1(i),B2(j),bb(k), a=l; cout Constructor A. l endl; ,void print(), B1:print(); B2:print();,cout a , bb.getb3() endl; ;,void main() A aa(1,2,3,4); aa.print(); ,【,例4-05-2,】,测试多重继承关系下，基类和派生类的构造函数的执行顺序。,#include “iostream.h”,class,B1,protected,:,int b1;,public,:,B1(int val1), b1=val1;,cout”base1 is called “endl; ;,class,B2,protected,:,int b2;,public,:,B2(int val2), b2=val2;,cout”base2 is called”endl; ,;,class,D：,public,B1,public,B2,protected,:,int d;,public,:,D(int val1, int val2, int val3);,D:D(int val1, int val2, int val3):B1(val1),B2(val2),/如改为D:D(int val1, int val2, int val3): B2(val2)，B1(val1)效果一样, d=val3; cout”erived class is called “ ;,void main() D dobj(1,2,3); ,该程序的执行结果是：,base1 is called,base2 is called,erived class is called,4.5.1 虚基类的引入与定义,多重继承下，一个派生类可从多个基类派生出来，又由于一个基类可派生出多个派生类，因此可能会产生一个类是通过多条路径从一个给定的类中派生出来的，如图4.1所示。,派生类,D3,中将继承两份类,B,的成员，一份由类,D1,派生得到，另一份由,D2,派生而来，这时通过派生类D3的对象访问类,D1,和,D2,的成员不会有问题，但访问类,B,的成员就会出现模棱两可的现象，编译程序不知道到底要访问哪一份的成员，C+为此提供了,虚基类,，以,解决,这种,二义性,。,B,D1,(B),D2,(B),D3,(B) (B),图4.1多重继承的二义性,虚基类,是这样的一个基类：它虽然被一个派生类间接地多次继承，但派生类却,只继承一份,该基类的成员，这样，避免了在派生类中访问这些成员时产生二义性。,1) 虚基类的说明格式,将一个基类声明为虚基类必须在各派生类定义时，在基类的名称前面加上关键字,virtual,格式如下：,class,派生类名:,virtual,共同基类名, /声明派生类成员 ；,/继承方式：,public 、 private、protected,#include /例,class A ,protected:,int a;,public:,void f(); ;,class,B:,virtual,public,A ,protected:,int b; ;,class C:,virtual,public,A ,protected:,int c; ;,class D:,public,B,public,C,int,d;,public:,void,g(); ;,/,Dg(),d,(Af(),a) (Af(),a),Cc,(Af(),a),Bb,(Af(),a),Af(),a,图4-3不使用虚基类的情况,当用类D说明一个对象dl时，该对象中只存在一个虚基类的子对象。因此，左面的访问是正确的：,virtual,virtual,D d1; d1.f();,/正确,void D:g() a=12; f(); ,A *pa;,pa=,图4-2 使用虚基类的情况,Dg(),d,(Af(),a),Cc,(Af(),a),Bb,(Af(),a),Af(),a,4.5.2 虚基类的初始化,虚基类的初始化与一般多继承的初始化在语法上相同，但构造函数的调用顺序有所不同，规则如下：,先调用虚基类的构造函数，再调用非虚基类的构造函数。,若同一层次中包含多个虚基类，其调用顺序按定义时顺序。,若虚基类由非虚基类派生而来，则仍按先调用基类构造函数，再调用派生类构造函数的顺序。,1）,从以上规则可知，使用虚基类时，要特,别注意,派生类的构造函数，对于,普通基类,，,派生类,的构造函数负责,调用,其,直接基类,的构造函数以初始化其直接基类的数据成员，而对于,虚基类,的任何派生类，其构造函数不仅负责调用直接基类的构造函数，还要调用虚基类的构造函数。,如,图4.4,所示结构，若基类,B,被,D1,、,D2,声明为虚基类，则派生类D3将调用三个基类(,D1,、,D2,的虚基类,B,和直接基类,D1,、,D2,)的构造函数，而派生类,D1,和,D2,不会调用其虚基类,B,的构造函数，只由最终端的派生类D3负责调用各基类的构造函数。,B,D1,(B),D2,(B),D3,(B),图4.4多重继承的二义性,2),为初始化基类子对象，派生类构造函数要调用基类的构造函数。对于虚基类来说，派生类对象中只有一个虚基类子对象，故必须保证虚基类子对象只被初始化一次。,由于继承结构的层次可能很深，将在建立对象时所指定的类称为最派生类。C+规定，虚基类的子对象是由最派生类的构造函数通过调用虚基类的构造函数进行初始化。如果一个派生类有一个直接或间接的虚基类，那么派生类构造函数的初始化列表中必须列出对虚基类构造函数的调用，如果没有列出，则表示使用该虚基类的缺省构造函数来初始化派生类对象中的虚基类子对象。,从虚基类直接或间接继承的派生类中的构造函数的成员初始化列表中都要列出这个虚基类构造函数的调用，但是，只有用于建立对象的那个最派生类的构造函数调用虚基类的构造函数，而该派生类的基类中列出的对这个虚基类的构造函数调用在执行中被忽略，这样保证了对虚基类的子对象只初始化一次。,如教材例4-11中Level1、Level2的虚基类构造函数被忽略,C+又规定，在一个成员初始列表中，虚基类的构造函数先于非虚基类的构造函数的执行。,分析教材 例4-11 程序调用顺序 P100101,toplevellevel2 base1: class base1先虚基,base2: class base2后非虚基, : class level2调自身,level1base2: class base2, : class level1, : class toplevel,base1,base2,level1,level2,toplevel,在,base1已初始化再调用时不再初始化保证初始化1次,#include,/补充例4-13,class,A,public:,A(const char *s) cout s endl;,A() ;,class,B:,virtual public,A,public:,B (const char *s1,const char * s2):A(s1), cout s2 endl; ;,class,C:,virtual public,A,public:,C(const char *s1,const char * s2):A(s1), cout s2 endl; ;,class,D:,public,B,public,C,public:,D(const char *s1,const char * s2,const char *s3,const char * s4):B(s1,s2),C(s1,s3),A(s1), cout s4 endl; ;,运行结果：,class A,class B,class C,class D,void main(), D *ptr=new D(class A,class B,class C,class D);,delete ptr; ,/ 该例中，A，B，C 三个类之间的关系用DAG图表示如图4-4,AA(),A(),BB(),CC(),DD(),图4-4 虚拟基类的初始化,B,去虚基,class A,class A,class B,class C,class D,B,去虚基,class A,class B,class A,class C,class D,class,B:,/*,virtual,*/,public,A,class,C:,/*,virtual,*/,public,A,在派生类B，C中使用了虚基类，使得建立的D类对象中只有一个虚基类子对象。 在派生类B，C，D的构造函数的成员初始化列表中都包含了对虚基类构造函数的调用。在建立D对象时，只有类D的构造函数的初始化列表中列出的虚基类构造函数被调用，而类D的基类的构造函数的初始化列表中列出的虚基类构造函数不被执行。,【例】,class,B,/定义类B,protected,:,int b;,public,:,B(int bval=0) b=bval;cout“Bn”; ;,class,D1:,virtual,public,B,protected,:,int d1;,public,:,D1(int bval, int dval); ;,D1:D1(int bval, int dval):B(bval), d1=dval; cout“D1n”;,class,D2:,virtual,public,B,protected,:,int d2;,public,:,D2(int bval, int dval ); ;,D2:D2(int bval,int dval):B(bval),d2=dval; cout“D2n”; ,class,D3:,public,D1,public,D2,protected,:,int d3;,public,:,D3(int bval, int dval1,int dval2,int dval3);,;,D3:D3(int bval, int dval1,int dval2,int dval3):D1(bval, dval1),D2(bval, dval2),B(bval), d3=dval3; cout“D3n”;,void main(),class,D3 d3(1,2,3,4);,例,class,A,public,:,A(const char *s) cout s endl;,A() ;,class,B:,virtual,public,A,public,:,B (const char *s1,const char * s2):A(s1), cout s2 endl; ;,class,C:,virtual,public,A,public,:,C(const char *s1,const char * s2):A(s1), cout s2 endl; ;,class,D:,public,B,public,C,public,:,D(const char *s1,const char * s2,const char *s3,const char * s4):B(s1,s2),C(s1,s3),A(s1), cout s4 endl; ;,AA(),A(),BB(),CC(),DD(),程序的执行结果为： class A,class B,class C,class D,该例中，A，B，C三个类之间的关系用DAG图表示如右图：,void main(), D *ptr=new D(class A,class B,class C,class D);,delete ptr; ,kWoZr$u(x+A2E5H9KcNfRiUlXp#s%v)y0C3F6IaLdOgSjVnYq!t*w-z1D4G8JbMeQhTkWoZr%u(x+B2E5H9KcOfRiUmXp#s&v)z0C3F7IaLdPgSkVnYq$t*w-A1D4G8JbNeQhTlWoZr%u(y+B2E6H9KcOfRjUmXp!s&v)z0C4F7IaMdPgSkVnZq$t*x-A1D5G8KbNeQiTlWo#r%v(y+B3E6H9LcOgRjUmYp!s&w)z0C4F7JaMdPhSkVnZq$u*x-A2D5G8KbNfQiTlXo#r%v(y0B3E6I9LcOgRjVmYp!t&w)z1C4G7JaMePhSkWnZr$u*x+A2D5H8KbNfQiUlXo#s%v(y0B3F6I9LdOgRjVmYq!t&w-z1C4G7JbMePhTkWnZr$u(x+A2E5H8KcNfRiUlXp#s%v)y0C3F6IaLdOgSjVnYq!t*w-z1D4G7JbMeQhTkWoZr$u(x+B2E5H9KcNfRiUmXp#s&v)y0C3F7IaLdPgSjVnYq$t*w-A1D4G8JbNeQhTlWoZr%u(y+B2E6H9KcOfRiUmXp!s&v)z0C3F7IaMdPgSkVnYq$t*x-A1D5G8JbNeQiTlWo#r%u(y+B3E6H9LcOfRjUmYp!s&w)z0C4F7JaMdPhSkVnZq$t*x-A2D5G8KbNeQiTlXo#r%v(y+B3E6I9LcOgRjUmYp!t&w)z1C4F7JaMePhSkWnZq$u*x+A2D5H8KbNfQiUlXo#s%v(y0B3F6I9LdOgRjVmYp!t&w-z1C4G7JaMePhTkWnZr$u*x+A2E5H8KcNfQiUlXp#s%v)y0B3F6IaLdOgSjVmYq!t*w-z1D4G7JbMeQhTkWoZr$u(x+A2E5H9KcNfRiUlXp#s&v)y0C3F6IaLdPgSjVnYq!t*w-A1D4G8JbMeQhTlWoZr%u(x+B2E6H9KcOfRiUmXp!s&v)z0C3F7IaLdPgSkVnYq$t*w-A1D5G8JbNeQhTlWo#r%u(y+B2E6H9LcOfRjUmXp!s&w)z0C4F7IaMdPhSkVnZq$t*x-A2D5G8KbRiUmXp#s&v)z0C3F7IaLdPgSkVnYq$t*w-A1D5G8JbNeQhTlWo#r%u(y+B2E6H9LcOfRjUmXp!s&w)z0C4F7IaMdPhSkVnZq$t*x-A1D5G8KbNeQiTlWo#r%v(y+B3E6H9LcOgRjUmYp!s&w)z1C4F7JaMdPhSkWnZq$u*x-A2D5H8KbNfQiTlXo#s%v(y0B3E6I9LdOgRjVmYp!t&w)z1C4G7JaMePhSkWnZr$u*x+A2D5H8KcNfQiUlXo#s%v)y0B3F6I9LdOgSjVmYq!t&w-z1D4G7JbMePhTkWoZr$u(x+A2E5H8KcNfRiUlXp#s%v)y0C3F6IaLdOgSjVnYq!t*w-z1D4G8JbMeQhTkWoZr%u(x+B2E5H9KcOfRiUmXp#s&v)z0C3F7IaLdPgSjVnYq$t*w-A1D4G8JbNeQhTlWoZr%u(y+B2E6H9KcOfRjUmXp!s&v)z0C4F7IaMdPgSkVnZq$t*x-A1D5G8KbNeQiTlWo#r%v(y+B3E6H9LcOfRjUmYp!s&w)z0C4F7JaMdPhSkVnZq$u*x-A2D5G8KbNfQiTlXo#r%v(y0B3E6I9LcOgRjVmYp!t&w)z1C4G7JaMePhSkWnZq$u*x+A2D5H8KbNfQiUlXo#s%v(y0B3F6I9LdOgRjVmYq!t&w-z1C4G7JbMePhTkWnZr$u(x+A2E5H8KcNfRiUlXp#s%v)y0C3F6IaLdOgSjVmYq!t*w-z1D4G7JbMeQhTkWoZr$u(x+B2E5H9KcNfRiUmXp#s&v)y0C3F7IaLdPgSjVnYq$t*w-A1D4G8JbNeQhTlWoZr%u(x+B2E6H9KcOfRiUmXp!s&v)z0C3F7IaMdPgSkVnYq$t*x-A1D5G8JbNeQiTlWo#r%u(y+B3E6H9LSjVnYq$t*w-A1D4G8JbMeQhTlWoZr%u(x+B2E6H9KcOfRiUmXp!s&v)z0C3F7IaMdPgSkVnYq$t*x-A1D5G8JbNeQiTlWo#r%u(y+B3E6H9LcOfRjUmXp!s&w)z0C4F7IaMdPhSkVnZq$t*x-A2D5G8KbNeQiTlXo#r%v(y+B3E6I9LcOgRjUmYp!t&w)z1C4F7JaMePhSkWnZq$u*x-A2D5H8KbNfQiTlXo#s%v(y0B3E6I9LdOgRjVmYp!t&w-z1C4G7JaMePhTkWnZr$u*x+A2E5H8KcNfQiUlXp#s%v)y0B3F6IaLdOgSjVmYq!t&w-z1D4G7JbMePhTkWoZr$u(x+A2E5H9KcNfRiUlXp#s&v)y0C3F6IaLdPgSjVnYq!t*w-A1D4G8JbMeQhTlWoZr%u(x+B2E5H9KcOfRiUmXp#s&v)z0C3F7IaLdPgSkVnYq$t*w-A1D5G8JbNeQhTlWo#r%u(y+B2E6H9LcOfRjUmXp!s&w)z0C4F7IaMdPgSkVnZq$t*x-A1D5G8KbNeQiTlWo#r%v(y+B3E6H9LcOgRjUmYp!s&w)z1C4F7JaMdPhSkWnZq$u*x-A2D5H8KbNfQiTlXo#s%v(y0B3E6I9LcOgRjVq$t*x-A1D5G8KbNeQiTlWo#r%v(y+B3E6H9LcOgRjUmYp!s&w)z1C4F7JaMdPhSkWnZq$u*x-A2D5G8KbNfQiTlXo#r%v(y0B3E6I9LcOgRjVmYp!t&w)z1C4G7JaMePhSkWnZr$u*x+A2D5H8KcNfQiUlXo#s%v)y0B3F6I9LdOgSjVmYq!t&w-z1C4G7JbMePhTkWnZr$u(x+A2E5H8KcNfRiUlXp#s%v)y0C3F6IaLdOgSjVnYq!t*w-z1D4G8JbMeQhTkWoZr%u(x+B2E5H9KcNfRiUmXp#s&v)y0C3F7IaLdPgSjVnYq$t*w-A1D4G8JbNeQhTlWoZr%u(y+B2E6H9KcOfRjUmXp!s&v)z0C4F7IaMdPgSkVnYq$t*x-A1D5G8JbNeQiTlWo#r%u(y+B3E6H9LcOfRjUmYp!s&w)z0C4F7JaMdPhSkVnZq$u*x-A2D5G8KbNfQiTlXo#r%v(y0B3E6I9LcOgRjUmYp!t&w)z1C4F7JaMePhSkWnZq$u*x+A2D5H8KbNfQiUlXo#s%v(y0B3F6I9LdOgRjVmYq!t&w-z5G8KbNeQiTlXo#r%v(y+B3E6I9LcOgRjUmYp!t&w)z1C4F7JaMePhSkWnZq$u*x+A2D5H8KbNfQiUlXo#s%v(y0B3F6I9LdOgRjVmYq!t&w-z1C4G7JaMePhTkWnZr$u*x+A2E5H8KcNfQiUlXp#s%v)y0B3F6IaLdOgSjVmYq!t*w-z1D4G7JbMeQhTkWoZr$u(x+B2E5H9KcNfRiUlXp#s&v)y0C3F6IaLdPgSjVnYq!t*w-A1D4G8JbMeQhTlWoZr%u(x+B2E6H9KcOfRiUmXp!s&v)z0C3F7IaMdPgSkVnYq$t*x-A1D5G8JbNeQhTlWo#r%u(y+B2E6H9LcOfRjUmXp!s&w)z0C4F7IaMdPhSkVnZq$t*x-A2D5G8KbNeQiTlXo#r%v(y+B3E6I9LcOgRjUmY*w-A1D5G8JbNeQhTlWo#r%u(y+B2E6H9LcOfRjUmXp!s&w)z0C4F7IaMdPhSkVnZq$t*x-A2D5G8KbNeQiTlWo#r%v(y+B3E6H9LcOgRjUmYp!s&w)z1C4F7JaMdPhSkWnZq$u*x-A2D5H8KbNfQiTlXo#s%v(y0B3E6I9LdOgRjVmYp!t&w-z1C4G7JaMePhSkWnZr$u*x+A2D5H8KcNfQiUlXo#s%v)y0B3F6I9LdOgSjVmYq!t&w-z1D4G7JbMePhTkWoZr$u(x+A2E5H9KcNfRiUlXp#s%v)y0C3F6IaLdOgSjVnYq!t*w-z1D4G8JbMeQhTkWoZr%u(x+B2E5H9KcOfRiUmXp#s&v)z0C3F7IaLdPgSkVnYq$t*w-A1D5G8JbNeQhTlWoZr%u(y+B2E6H9KcOfRjUmXp!s&v)z0C4F7IaMdPgSkVnZq$t*x-A1D5G8KbNeQiTlWo#r%v(y+B3E6H9LcOgRjUmYp!s&w)z0C4F7JaMdPhSkVnZq$u*x-A2D5G8KbNfUmXp!s&v)z0C4F7IaMdPgSkVnZq$t*x-A1D5G8KbNeQiTlWo#r%v(y+B3E6H9LcOfRjUmYp!s&w)z0C4F7JaMdPhSkVnZq$u*x-A2D5G8KbNfQiTlXo#r%v(y0B3E6I9LcOgRjVmYp!t&w)z1C4G7JaMePhSkWnZq$u*x+A2D5H8KbNfQiUlXo#s%v(y0B3F6I9LdOgRjVmYq!t&w-z1C4G7JbMePhTkWnZr$u(x+A2E5H8KcNfRiUlXp#s%v)y0B3F6IaLdOgSjVmYq!t*w-z1D4G7JbMeQhTkWoZr$u(x+B2E5H9KcNfRiUmXp#s&v)y0C3F7IaLdPgSjVnYq$t*w-A1D4G8JbNeQhTlWoZr%u(x+B2E6H9KcOfRiUmXp!s&v)z0C3F7IaMdPgSkVnYq$t*x-A1D5G8JbNeQiTlWo#r%u(y+B3E6H9LcOfRjUmYp!s&w)z0C4F7IaMdlWoZr%u(x+B2E6H9KcOfRiUmXp!s&v)z0C3F7IaMdPgSkVnYq$t*x-A1D5G8JbNeQiTlWo#r%u(y+B3E6H9LcOfRjUmXp!s&w)z0C4F7IaMdPhSkVnZq$t*x-A2D5G8KbNeQiTlXo#r%v(y+B3E6I9LcOgRjUmYp!t&w)z1C4F7JaMePhSkWnZq$u*x-A2D5H8KbNfQiTlXo#s%v(y0B3E6I9LdOgRjVmYp!t&w-z1C4G7JaMePhTkWnZr$u*x+A2E5H8KcNfQiUlXp#s%v)y0B3F6I9LdOgSjVmYq!t&w-z1D4G7JbMePhTkWoZr