『牛角书』鸿蒙实现俄罗斯方块 原创

public class MainAbilitySlice extends AbilitySlice {
    private DirectionalLayout layout;//布局    private static final int length=100;//方格的边长    private static final int interval=2;//方格的间距    private static final int[][] RedGrids1={{0,3},{0,4},{1,4},{1,5}};//红色方块形态1    private static final int[][] RedGrids2={{0,5},{1,5},{1,4},{2,4}};//红色方块形态2    private static final int[][] GreenGrids1={{0,5},{0,4},{1,4},{1,3}};//绿色方块形态1    private static final int[][] GreenGrids2={{0,4},{1,4},{1,5},{2,5}};//绿色方块形态2    private static final int[][] CyanGrids1={{0,4},{1,4},{2,4},{3,4}};//蓝绿色方块形态1    private static final int[][] CyanGrids2={{0,3},{0,4},{0,5},{0,6}};//蓝绿色方块形态2    private static final int[][] MagentaGrids1={{0,4},{1,3},{1,4},{1,5}};//品红色方块形态1    private static final int[][] MagentaGrids2={{0,4},{1,4},{1,5},{2,4}};//品红色方块形态2    private static final int[][] MagentaGrids3={{0,3},{0,4},{0,5},{1,4}};//品红色方块形态3    private static final int[][] MagentaGrids4={{0,5},{1,5},{1,4},{2,5}};//品红色方块形态4    private static final int[][] BlueGrids1={{0,3},{1,3},{1,4},{1,5}};//蓝色方块形态1    private static final int[][] BlueGrids2={{0,5},{0,4},{1,4},{2,4}};//蓝色方块形态2    private static final int[][] BlueGrids3={{0,3},{0,4},{0,5},{1,5}};//蓝色方块形态3    private static final int[][] BlueGrids4={{0,5},{1,5},{2,5},{2,4}};//蓝色方块形态4    private static final int[][] WhiteGrids1={{0,5},{1,5},{1,4},{1,3}};//白色方块形态1    private static final int[][] WhiteGrids2={{0,4},{1,4},{2,4},{2,5}};//白色方块形态2    private static final int[][] WhiteGrids3={{0,5},{0,4},{0,3},{1,3}};//白色方块形态3    private static final int[][] WhiteGrids4={{0,4},{0,5},{1,5},{2,5}};//白色方块形态4    private static final int[][] YellowGrids={{0,4},{0,5},{1,5},{1,4}};//黄色方块形态1    private static final int grids_number=4;//方块所占方格的数量，固定为4    private int[][] grids;//描绘方格颜色的二维数组    private int[][] NowGrids;//当前方块的形态    private int row_number;//方块的总行数    private Text score_t;
    private int score=0;//分数    private int column_number;//方块的总列数    private int Nowrow;//向下移动的行数    private int Nowcolumn;//向左右移动的列数，减1表示左移，加1表示右移    private int Grids;//当前方格的颜色，0表示灰色，1代表红色，2代表绿色，3代表蓝绿色，4代表品红色，5代表蓝色，6代表白色，7代表黄色    private int column_start;//方块的第一个方格所在二维数组的列数    private Timer timer;//时间
    public void onStart(Intent intent) {
        super.onStart(intent);

        initialize();
        run();
    }

    public void initialize(){//(重新)开始游戏        layout = new DirectionalLayout(this);
        grids = new int[15][10];
        for(int row = 0; row < 15; row++)
            for(int column = 0; column < 10; column++)
                grids[row][column] = 0;

        createGrids();
        score_t=new Text(this);
        score_t.setText("Score: 0");
        score_t.setTextSize(50);
        score_t.setTextColor(Color.BLUE);
        score_t.setTextAlignment(TextAlignment.CENTER);
        score_t.setMarginsTopAndBottom(0,0);
        score_t.setMarginsLeftAndRight(300,0);
        layout.addComponent(score_t);
        setUIContent(layout);

        drawButton();
        drawGrids();
    }

    public void createGrids(){//随机生成一个颜色方块        Nowcolumn = 0;
        Nowrow = 0;

        eliminateGrids();

        double random = Math.random();
        if(random >= 0 && random < 0.2){
            if(random >= 0 && random < 0.1)
                createRedGrids1();
            else                createRedGrids2();
        }
        else if(random >= 0.2 && random < 0.4){
            if(random >= 0.2 && random < 0.3)
                createGreenGrids1();
            else                createGreenGrids2();
        }
        else if(random >= 0.4 && random < 0.45){
            if(random >= 0.4 &&random < 0.43)
                createCyanGrids1();
            else                createCyanGrids2();
        }
        else if(random >= 0.45 && random < 0.6){
            if(random >= 0.45 && random < 0.48)
                createMagentaGrids1();
            else if(random >= 0.48 && random < 0.52)
                createMagentaGrids2();
            else if(random >= 0.52 && random < 0.56)
                createMagentaGrids3();
            else                createMagentaGrids4();
        }
        else if(random >= 0.6 && random < 0.75){
            if(random >= 0.6 && random < 0.63)
                createBlueGrids1();
            else if(random >= 0.63 && random < 0.67)
                createBlueGrids2();
            else if(random >= 0.67 && random < 0.71)
                createBlueGrids3();
            else                createBlueGrids4();
        }
        else if(random >= 0.75 && random < 0.9){
            if(random >= 0.75 && random < 0.78)
                createWhiteGrids1();
            else if(random >=0.78 && random < 0.82)
                createWhiteGrids2();
            else if(random >=0.82 && random < 0.86)
                createWhiteGrids3();
            else                createWhiteGrids4();
        }
        else {
            createYellowGrids();
        }

        if(gameover() == false){//当游戏未有结束时才生成新的颜色方块            for(int row = 0; row < grids_number; row++){//将颜色方块对应的Grids添加到二维数组中                grids[NowGrids[row][0] + Nowrow][NowGrids[row][1] + Nowcolumn] = Grids;
            }
        }
        else{//当游戏结束时停止时间和绘制游戏结束文本            timer.cancel();
            drawText();
        }
    }

    public void drawButton(){//绘制按钮        ShapeElement background = new ShapeElement();
        background.setRgbColor(new RgbColor(174, 158, 143));
        background.setCornerRadius(100);

        Button button1 = new Button(this);//左移按钮        button1.setText("←");
        button1.setTextAlignment(TextAlignment.CENTER);
        button1.setTextColor(Color.WHITE);
        button1.setTextSize(100);
        button1.setMarginTop(1800);
        button1.setMarginLeft(160);
        button1.setPadding(10,0,10,0);
        button1.setBackground(background);
        button1.setClickedListener(new Component.ClickedListener() {
            @Override
            public void onClick(Component component) {
                leftShift();
            }
        });
        layout.addComponent(button1);

        Button button2 = new Button(this);//变换按钮        button2.setText("↑");
        button2.setTextAlignment(TextAlignment.CENTER);
        button2.setTextColor(Color.WHITE);
        button2.setTextSize(100);
        button2.setMarginLeft(480);
        button2.setMarginTop(-130);
        button2.setPadding(10,0,10,0);
        button2.setBackground(background);
        button2.setClickedListener(new Component.ClickedListener() {
            @Override
            public void onClick(Component component) {
                changGrids();
            }
        });
        layout.addComponent(button2);

        Button button3 = new Button(this);//右移按钮        button3.setText("→");
        button3.setTextAlignment(TextAlignment.CENTER);
        button3.setTextColor(Color.WHITE);
        button3.setTextSize(100);
        button3.setMarginLeft(780);
        button3.setMarginTop(-130);
        button3.setPadding(10,0,10,0);
        button3.setBackground(background);
        button3.setClickedListener(new Component.ClickedListener() {
            @Override
            public void onClick(Component component) {
                rightShift();
            }
        });
        layout.addComponent(button3);

        Button button = new Button(this);
        button.setText("重新开始");
        button.setTextSize(100);
        button.setTextAlignment(TextAlignment.CENTER);
        button.setTextColor(Color.WHITE);
        button.setMarginTop(5);
        button.setMarginLeft(310);
        button.setPadding(10,10,10,10);
        button.setBackground(background);
        button.setClickedListener(new Component.ClickedListener() {
            @Override
            public void onClick(Component component) {
                drawScore(score=0);
                initialize();
                run();
            }
        });
        layout.addComponent(button);
    }

    public void drawGrids(){//绘制背景图和方格        layout.setLayoutConfig((new ComponentContainer.LayoutConfig(ComponentContainer.LayoutConfig.MATCH_PARENT,ComponentContainer.LayoutConfig.MATCH_PARENT)));

        Component.DrawTask task=new Component.DrawTask() {
            @Override
            public void onDraw(Component component, Canvas canvas) {
                Paint paint = new Paint();

                paint.setColor(Color.BLACK);
                RectFloat rect=new RectFloat(30-20,250-20,length*10+interval*9+30+20,length*15+interval*14+250+20);
                canvas.drawRect(rect,paint);//绘制背景图
                for(int row = 0; row < 15; row++){//0表示灰色，1代表红色，2代表绿色，3代表蓝绿色，4代表品红色，5代表蓝色，6代表白色，7代表黄色                    for(int column = 0; column < 10; column++){
                        if(grids[row][column] == 0)
                            paint.setColor(Color.GRAY);
                        else if(grids[row][column] == 1)
                            paint.setColor(Color.RED);
                        else if(grids[row][column] == 2)
                            paint.setColor(Color.GREEN);
                        else if(grids[row][column] == 3)
                            paint.setColor(Color.CYAN);
                        else if(grids[row][column] == 4)
                            paint.setColor(Color.MAGENTA);
                        else if(grids[row][column] == 5)
                            paint.setColor(Color.BLUE);
                        else if(grids[row][column] == 6)
                            paint.setColor(Color.WHITE);
                        else if(grids[row][column] == 7)
                            paint.setColor(Color.YELLOW);
                        RectFloat rectFloat=new RectFloat(30+column*(length+interval),250+row*(length+interval),30+length+column*(length+interval),250+length+row*(length+interval));
                        canvas.drawRect(rectFloat,paint);//绘制方格                    }
                }
            }
        };

        layout.addDrawTask(task);
        setUIContent(layout);
    }

    public void changGrids(){//变换方块的形状        for(int row = 0; row < grids_number; row++){//将原来的颜色方块清除            grids[NowGrids[row][0] + Nowrow][NowGrids[row][1] + Nowcolumn] = 0;
        }
        if(column_number == 2 && Nowcolumn + column_start == 0){
            Nowcolumn++;
        }

        //根据Grids的颜色值调用改变方块形状的"chang+Color+Grids"函数        if(Grids==1){
            changRedGrids();
        }
        else if(Grids==2){
            changeGreenGrids();
        }
        else if(Grids==3){
            changeCyanGrids();
        }
        else if(Grids==4){
            changeMagentaGrids();
        }
        else if(Grids==5){
            changeBlueGrids();
        }
        else if(Grids==6){
            changeWhiteGrids();
        }

        for(int row = 0; row < grids_number; row++){//重新绘制颜色方块            grids[NowGrids[row][0] + Nowrow][NowGrids[row][1] + Nowcolumn] = Grids;
        }

        drawGrids();
    }

    public void drawScore(int t){//绘制分数        score_t.setText("Score: "+score*10);
    }
    public void drawText(){//绘制游戏结束文本        Text text=new Text(this);
        text.setText("游戏结束");
        text.setTextSize(50);
        text.setTextColor(Color.RED);
//        text.setPadding(0,0,0,0);        text.setTextAlignment(TextAlignment.CENTER);
        text.setMarginsTopAndBottom(-2000,300);
        text.setMarginsLeftAndRight(300,0);
        layout.addComponent(text);
        setUIContent(layout);
    }

    public void run(){//方块随着时间逐渐下移        timer=new Timer();
        timer.schedule(new TimerTask() {//每隔750毫秒下移一格            @Override
            public void run() {
                getUITaskDispatcher().asyncDispatch(()->{
                    if(down()){//如果方块能下移则下移，否则重新随机生成新的方块                        for(int row = 0; row < grids_number; row++){//将原来的颜色方块清除                            grids[NowGrids[row][0] + Nowrow][NowGrids[row][1] + Nowcolumn] = 0;
                        }
                        Nowrow++;
                        for(int row = 0; row < grids_number; row++){//重新绘制颜色方块                            grids[NowGrids[row][0] + Nowrow][NowGrids[row][1] + Nowcolumn] = Grids;
                        }
                    }
                    else{
                        createGrids();
                    }
                    drawGrids();
                });
            }
        },0,750);
    }

    public boolean down(){//判断方块能否下移        boolean k;
        if(Nowrow + row_number == 15){//如果方块向下移动到下边界，则返回false            return false;
        }

        for(int row = 0; row < grids_number; row++){//当下边缘方块再下一格为空时则可以下移            k = true;
            for(int i = 0; i < grids_number; i++){
                if(NowGrids[row][0] + 1 == NowGrids[i][0] && NowGrids[row][1] == NowGrids[i][1]){//找出非下边缘方块                    k = false;
                }
            }
            if(k){//当任一下边缘方块再下一格不为空时返回false                if(grids[NowGrids[row][0] + Nowrow + 1][NowGrids[row][1] + Nowcolumn] != 0)
                    return false;
            }
        }

        return true;
    }

    public void leftShift(){//方块向左移动一格        if(left()){//当方块能向左移动时则左移            for(int row = 0; row < grids_number; row++){//将原来的颜色方块清除                grids[NowGrids[row][0] + Nowrow][NowGrids[row][1] + Nowcolumn] = 0;
            }
            Nowcolumn--;
            for(int row = 0; row < grids_number; row++){//重新绘制颜色方块                grids[NowGrids[row][0] + Nowrow][NowGrids[row][1] + Nowcolumn] = Grids;
            }
        }
        drawGrids();
    }

    public boolean left(){//判断方块能否向左移动        boolean k;
        if(Nowcolumn + column_start == 0){//如果方块向左移动到左边界，则返回false            return false;
        }

        for(int column = 0; column < grids_number; column++){//当左边缘方块再左一格为空时则可以左移            k = true;
            for(int j = 0; j < grids_number; j++){
                if(NowGrids[column][0] == NowGrids[j][0] && NowGrids[column][1] - 1 == NowGrids[j][1]){//找出非左边缘方块                    k = false;
                }
            }
            if(k){//当任一左边缘方块再左一格不为空时返回false                if(grids[NowGrids[column][0] + Nowrow][NowGrids[column][1] + Nowcolumn - 1] != 0)
                    return false;
            }
        }

        return true;
    }

    public void rightShift(){//方块向右移动一格        if(right()){//当方块能向右移动时则右移            for(int row = 0; row < grids_number; row++){//将原来的颜色方块清除                grids[NowGrids[row][0] + Nowrow][NowGrids[row][1] + Nowcolumn] = 0;
            }
            Nowcolumn++;
            for(int row = 0; row < grids_number; row++){//重新绘制颜色方块                grids[NowGrids[row][0] + Nowrow][NowGrids[row][1] + Nowcolumn] = Grids;
            }
        }
        drawGrids();
    }

    public boolean right(){//判断方块能否向右移动        boolean k;
        if(Nowcolumn + column_number + column_start==10){//如果方块向右移动到右边界，则返回false            return false;
        }

        for(int column = 0; column < grids_number; column++){//当右边缘方块再右一格为空时则可以右移            k = true;
            for(int j = 0; j < grids_number; j++){
                if(NowGrids[column][0] == NowGrids[j][0] && NowGrids[column][1] + 1 == NowGrids[j][1]){//找出非右边缘方块                    k = false;
                }
            }
            if(k){//当任一右边缘方块再右一格不为空时返回false                if(grids[NowGrids[column][0] + Nowrow][NowGrids[column][1] + Nowcolumn + 1] != 0)
                    return false;
            }
        }

        return true;
    }

    public void eliminateGrids() {//当有任一行全部填满颜色方块时，消去该行，且所有方格向下移动一格        boolean k;
        for (int row = 14; row >= 0; row--) {
            k = true;
            for (int column = 0; column < 10; column++) {//判断是否有任一行全部填满颜色方块                if (grids[row][column] == 0)
                    k = false;
            }
            if (k) {//消去全部填满颜色方块的行，且所有方格向下移动一格                drawScore(++score);
                for (int i = row - 1; i >= 0; i--) {
                    for (int j = 0; j < 10; j++) {
                        grids[i + 1][j] = grids[i][j];
                    }
                }
                for (int n = 0; n < 10; n++) {
                    grids[0][n] = 0;
                }
            }
        }
        drawGrids();
    }

    public boolean gameover(){//判断游戏是否结束，游戏结束返回true        for(int row = 0; row < grids_number; row++){//新生成的颜色方块覆盖原有的颜色方块则游戏结束            if(grids[NowGrids[row][0] + Nowrow][NowGrids[row][1] + Nowcolumn] != 0){
                return true;
            }
        }
        return false;
    }

    //以下为为各种颜色各种形状的方块赋予对应的NowGrids、row_number、column_number、Grids、column_start    public void createRedGrids1(){
        NowGrids=RedGrids1;
        row_number=2;
        column_number=3;
        Grids=1;
        column_start=3;
    }

    public void createRedGrids2(){
        NowGrids=RedGrids2;
        row_number=3;
        column_number=2;
        Grids=1;
        column_start=4;
    }

    public void createGreenGrids1(){
        NowGrids=GreenGrids1;
        row_number=2;
        column_number=3;
        Grids=2;
        column_start=3;
    }

    public void createGreenGrids2(){
        NowGrids=GreenGrids2;
        row_number=3;
        column_number=2;
        Grids=2;
        column_start=4;
    }

    public void createCyanGrids1(){
        NowGrids=CyanGrids1;
        row_number=4;
        column_number=1;
        Grids=3;
        column_start=4;
    }

    public void createCyanGrids2(){
        NowGrids=CyanGrids2;
        row_number=1;
        column_number=4;
        Grids=3;
        column_start=3;
    }

    public void createMagentaGrids1(){
        NowGrids=MagentaGrids1;
        row_number=2;
        column_number=3;
        Grids=4;
        column_start=3;
    }

    public void createMagentaGrids2(){
        NowGrids=MagentaGrids2;
        row_number=3;
        column_number=2;
        Grids=4;
        column_start=4;
    }

    public void createMagentaGrids3(){
        NowGrids=MagentaGrids3;
        row_number=2;
        column_number=3;
        Grids=4;
        column_start=3;
    }

    public void createMagentaGrids4(){
        NowGrids=MagentaGrids4;
        row_number=3;
        column_number=2;
        Grids=4;
        column_start=4;
    }

    public void createBlueGrids1(){
        NowGrids=BlueGrids1;
        row_number=2;
        column_number=3;
        Grids=5;
        column_start=3;
    }

    public void createBlueGrids2(){
        NowGrids=BlueGrids2;
        row_number=3;
        column_number=2;
        Grids=5;
        column_start=4;
    }

    public void createBlueGrids3(){
        NowGrids=BlueGrids3;
        row_number=2;
        column_number=3;
        Grids=5;
        column_start=3;
    }

    public void createBlueGrids4(){
        NowGrids=BlueGrids4;
        row_number=3;
        column_number=2;
        Grids=5;
        column_start=4;
    }

    public void createWhiteGrids1(){
        NowGrids=WhiteGrids1;
        row_number=2;
        column_number=3;
        Grids=6;
        column_start=3;
    }

    public void createWhiteGrids2(){
        NowGrids=WhiteGrids2;
        row_number=3;
        column_number=2;
        Grids=6;
        column_start=4;
    }

    public void createWhiteGrids3(){
        NowGrids=WhiteGrids3;
        row_number=2;
        column_number=3;
        Grids=6;
        column_start=3;
    }

    public void createWhiteGrids4(){
        NowGrids=WhiteGrids4;
        row_number=3;
        column_number=2;
        Grids=6;
        column_start=4;
    }

    public void createYellowGrids(){
        NowGrids=YellowGrids;
        row_number=2;
        column_number=2;
        Grids=7;
        column_start=4;
    }
    //以上为为各种颜色各种形状的方块赋予对应的NowGrids、row_number、column_number、Grids、column_start的值
    //以下为变换方块形状时调用新方块的"create+Color+Grids"函数，为新方块赋予对应的NowGrids、row_number、column_number、Grids、column_start的值    public void changRedGrids(){
        if(NowGrids==RedGrids1){
            createRedGrids2();
        }
        else if(NowGrids==RedGrids2){
            createRedGrids1();
        }
    }

    public void changeGreenGrids(){
        if(NowGrids==GreenGrids1){
            createGreenGrids2();
        }
        else if(NowGrids==GreenGrids2){
            createGreenGrids1();
        }
    }

    public void changeCyanGrids(){
        if(NowGrids==CyanGrids1){
            createCyanGrids2();
        }
        else if(NowGrids==CyanGrids2){
            createCyanGrids1();
        }
    }

    public void changeMagentaGrids(){
        if(NowGrids==MagentaGrids1){
            createMagentaGrids2();
        }
        else if(NowGrids==MagentaGrids2){
            createMagentaGrids3();
        }
        else if(NowGrids==MagentaGrids3){
            createMagentaGrids4();
        }
        else if(NowGrids==MagentaGrids4){
            createMagentaGrids1();
        }
    }

    public void changeBlueGrids(){
        if(NowGrids==BlueGrids1){
            createBlueGrids2();
        }
        else if(NowGrids==BlueGrids2){
            createBlueGrids3();
        }
        else if(NowGrids==BlueGrids3){
            createBlueGrids4();
        }
        else if(NowGrids==BlueGrids4){
            createBlueGrids1();
        }
    }

    public void changeWhiteGrids(){
        if(NowGrids==WhiteGrids1){
            createWhiteGrids2();
        }
        else if(NowGrids==WhiteGrids2){
            createWhiteGrids3();
        }
        else if(NowGrids==WhiteGrids3){
            createWhiteGrids4();
        }
        else if(NowGrids==WhiteGrids4){
            createWhiteGrids1();
        }
    }
    //以上为变换方块形状时调用新方块的"create+Color+Grids"函数，为新方块赋予对应的NowGrids、row_number、column_number、Grids、column_start的值
    @Override
    public void onActive() {
        super.onActive();
    }

    @Override
    public void onForeground(Intent intent) {
        super.onForeground(intent);
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.
213.
214.
215.
216.
217.
218.
219.
220.
221.
222.
223.
224.
225.
226.
227.
228.
229.
230.
231.
232.
233.
234.
235.
236.
237.
238.
239.
240.
241.
242.
243.
244.
245.
246.
247.
248.
249.
250.
251.
252.
253.
254.
255.
256.
257.
258.
259.
260.
261.
262.
263.
264.
265.
266.
267.
268.
269.
270.
271.
272.
273.
274.
275.
276.
277.
278.
279.
280.
281.
282.
283.
284.
285.
286.
287.
288.
289.
290.
291.
292.
293.
294.
295.
296.
297.
298.
299.
300.
301.
302.
303.
304.
305.
306.
307.
308.
309.
310.
311.
312.
313.
314.
315.
316.
317.
318.
319.
320.
321.
322.
323.
324.
325.
326.
327.
328.
329.
330.
331.
332.
333.
334.
335.
336.
337.
338.
339.
340.
341.
342.
343.
344.
345.
346.
347.
348.
349.
350.
351.
352.
353.
354.
355.
356.
357.
358.
359.
360.
361.
362.
363.
364.
365.
366.
367.
368.
369.
370.
371.
372.
373.
374.
375.
376.
377.
378.
379.
380.
381.
382.
383.
384.
385.
386.
387.
388.
389.
390.
391.
392.
393.
394.
395.
396.
397.
398.
399.
400.
401.
402.
403.
404.
405.
406.
407.
408.
409.
410.
411.
412.
413.
414.
415.
416.
417.
418.
419.
420.
421.
422.
423.
424.
425.
426.
427.
428.
429.
430.
431.
432.
433.
434.
435.
436.
437.
438.
439.
440.
441.
442.
443.
444.
445.
446.
447.
448.
449.
450.
451.
452.
453.
454.
455.
456.
457.
458.
459.
460.
461.
462.
463.
464.
465.
466.
467.
468.
469.
470.
471.
472.
473.
474.
475.
476.
477.
478.
479.
480.
481.
482.
483.
484.
485.
486.
487.
488.
489.
490.
491.
492.
493.
494.
495.
496.
497.
498.
499.
500.
501.
502.
503.
504.
505.
506.
507.
508.
509.
510.
511.
512.
513.
514.
515.
516.
517.
518.
519.
520.
521.
522.
523.
524.
525.
526.
527.
528.
529.
530.
531.
532.
533.
534.
535.
536.
537.
538.
539.
540.
541.
542.
543.
544.
545.
546.
547.
548.
549.
550.
551.
552.
553.
554.
555.
556.
557.
558.
559.
560.
561.
562.
563.
564.
565.
566.
567.
568.
569.
570.
571.
572.
573.
574.
575.
576.
577.
578.
579.
580.
581.
582.
583.
584.
585.
586.
587.
588.
589.
590.
591.
592.
593.