/*    ALIGN214
TESTING align CLAUSE*/

#include <math.h>
#include <stdlib.h>
#include <stdio.h>

static void align211();
static void align212();
static void align213();
static void align214();

static void align241();
static void align2421();
static void align2422();
static void align243();
static void align244();

static void ansyes(const char tname[]);
static void ansno(const char tname[]);

static int NL = 10000;
static int ER = 100000;
static int s, cs, erri, i, j, n, m, k, ia, ja, na, ma, ib, jb, nb, mb, Avalue, Bvalue;

int main(int an, char **as)
{
    printf("=== START OF ALIGN214 ======================\n");

/* ALIGN arrB[i] WITH arrA[1][i]   vector arrB on section
                                              (the first line of arrA)*/
    align211();
/* ALIGN arrB[i] WITH arrA[2 * i + 2][2] vector arrB on section
             (the second column of arrA) with stretching and shift*/
    align212();
/* ALIGN arrB[i] WITH arrA[][i] vector replication on every line of arrA*/
    align213();
/* ALIGN arrB[i] WITH arrA[2 * i + 2][] vector arrB on replication on
             every column of arrA with stretching and shift*/
    align214();

/*  ALIGN arrB[i][j][][] WITH arrA[i][j]
                     matrix compression*/
    align241();
/*  ALIGN arrB[][i][][j] WITH arrA[j+4][2*i] matrix compression*/
    align2421();
/*  ALIGN arrB[][i][][j] WITH arrA[j+1][2*i] small array*/
    align2422();
/*  ALIGN arrB[][][i][] WITH arrA[1][i] matrix compression
                                        and replication*/
    align243();
/*  ALIGN arrB[][][][i] WITH arrA[i][] matrix compression
                                    and replication*/
    align244();

    printf("=== END OF ALIGN214 ========================\n");
    return 0;
}
/* ---------------------------------------------ALIGN211  */
/* ALIGN arrB[i] WITH arrA[1][i]   vector arrB on section
                                 (the first line of arrA)*/
void align211()
{
/*    parameters for ALIGN arrB[i] WITH arrA[1][i]*/
    #define AN1 8
    #define AN2 8
    #define BN1 4
    int k1i = 0, k2i = 0, li = 1;
    int k1j = 1, k2j = 0, lj = 0;

    #pragma dvm array distribute[block][block]
    int A2[AN1][AN2];
    #pragma dvm array align([i] with A2[1][i])
    int B1[BN1];
    char tname[] = "align211";

    erri = ER;
    #pragma dvm actual(erri)
    #pragma dvm region local(A2, B1)
    {
    #pragma dvm parallel([i] on B1[i])
    for (i = 0; i < BN1; i++)
        B1[i] = 0;
    #pragma dvm parallel([i][j] on A2[i][j]) private(ib)
    for (i = 0; i < AN1; i++)
        for (j = 0; j < AN2; j++)
        {
            A2[i][j] = i * NL + j;
            if ((i == 1) && (j < BN1))
            {
                ib = j;
                B1[ib] = ib;
            }
        }
    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia, ja)
    for (i = 0; i < BN1; i++)
    {
        if (B1[i] != i)
            if (erri > i) erri = i;
        ia = 1;
        ja = i;
        if (A2[ia][ja] != (ia * NL + ja))
            if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
    }
    }
    #pragma dvm get_actual(erri)

    if (erri == ER)
        ansyes(tname);
    else
        ansno(tname);
    #undef AN1
    #undef AN2
    #undef BN1
}
/* ---------------------------------------------ALIGN212*/
/* ALIGN arrB[i] WITH arrA[2*i+2][2] vector arrB on section
                    (the second column of arrA) with stretching and shift*/
void align212()
{
    /*     parameters for ALIGN arrB[i] WITH arrA[2*i+2][2]*/
    #define AN1 14
    #define AN2 3
    #define BN1 6
    int k1i = 2, k2i = 0, li = 2;
    int k1j = 0, k2j = 0, lj = 2;

    #pragma dvm array distribute[block][block]
    int A2[AN1][AN2];
    #pragma dvm array align([i] with A2[k1i * i + li][lj])
    int B1[BN1];
    char tname[] = "align212";

    erri = ER;
    #pragma dvm actual(erri)
    #pragma dvm region local(A2, B1)
    {
    #pragma dvm parallel([i] on B1[i])
    for (i = 0; i < BN1; i++)
        B1[i] = 0;
    #pragma dvm parallel([i][j] on A2[i][j]) private(ib)
    for (i = 0; i < AN1; i++)
        for (j = 0; j < AN2; j++)
        {
            A2[i][j] = i * NL + j;
            if (j == lj){
                if (((i - li) == (((i - li) / k1i) * k1i)) &&
                    (((i - li) / k1i) >= 0) &&
                    (((i - li) / k1i) < BN1))
                {
                    ib = (i - li) / k1i;
                    B1[ib] = ib;
                }
            }
        }
    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia, ja)
    for (i = 0; i < BN1; i++)
    {
        if (B1[i] != i)
            if (erri > i) erri = i;
        ia = k1i * i + li;
        ja = lj;
        if (A2[ia][ja] != (ia * NL + ja))
            if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
    }
    }
    #pragma dvm get_actual(erri)

    if (erri == ER)
        ansyes(tname);
    else
        ansno(tname);
    #undef AN1
    #undef AN2
    #undef BN1
}
/* ---------------------------------------------ALIGN213*/
/* ALIGN arrB[i] WITH arrA[][i]  vector replication on every line of arrA*/
void align213()
{
/*     parameters for ALIGN arrB[i] WITH arrA[][k1j * i + lj]*/
    #define AN1 8
    #define AN2 8
    #define BN1 6
    int k1i = 0, k2i = 0, li = 0;
    int k1j = 1, k2j = 0, lj = 0;

    #pragma dvm array distribute[block][block]
    int A2[AN1][AN2];
    #pragma dvm array align([i] with A2[][k1j * i + lj])
    int B1[BN1];
    char tname[] = "align213";

    erri = ER;
    s = 0;
    #pragma dvm actual(erri, s)
    #pragma dvm region local(A2, B1)
    {
    #pragma dvm parallel([i] on B1[i])
    for (i = 0; i < BN1; i++)
        B1[i] = i;
    #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), private(ib)
    for (i = 0; i < AN1; i++)
        for (j = 0; j < AN2; j++)
        {
            A2[i][j] = i * NL + j;
            if (((j - lj) == (((j - lj) / k1j) * k1j)) &&
                (((j - lj) / k1j) >= 0) &&
                (((j - lj) / k1j) < BN1))
            {
                ib = (j - lj) / k1j;
                if (B1[ib] != ib)
                    if (erri > ib) erri = ib;
            }
        }
    #pragma dvm parallel([i] on B1[i]) reduction(min(erri), sum(s))
    for (i = 0; i < BN1; i++)
    {
        s = s + B1[i];
        if (B1[i] != i)
            if (erri > i) erri = i;
    }
    }
    #pragma dvm get_actual(erri, s)

    cs = (0 + BN1-1) * BN1 / 2;
    if ((erri == ER) && (s == cs))
        ansyes(tname);
    else
    {
        ansno(tname);
//        printf("%d, %d, %d\n", erri, s, cs);
    }
    #undef AN1
    #undef AN2
    #undef BN1
}
/* ---------------------------------------------ALIGN214*/
/* ALIGN arrB[i] WITH arrA[2*i+2][ ] vector arrB on replication on
             every column of arrA with stretching and shift*/
void align214()
{
/*     parameters for ALIGN arrB[i] WITH arrA[k1i*i+li][]*/
    #define AN1 28
    #define AN2 8
    #define BN1 5
    int k1i = 2, k2i = 0, li = 2;
    int k1j = 0, k2j = 0, lj = 0;

    #pragma dvm array distribute[block][block]
    int A2[AN1][AN2];
    #pragma dvm array align([i] with A2[k1i * i + li][])
    int B1[BN1];
    char tname[] = "align214";

    erri = ER;
    s = 0;
    #pragma dvm actual(erri, s)
    #pragma dvm region local(A2, B1)
    {
    #pragma dvm parallel([i] on B1[i])
    for (i = 0; i < BN1; i++)
        B1[i] = i;
    #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), private(ib)
    for (i = 0; i < AN1; i++)
        for (j = 0; j < AN2; j++)
        {
            A2[i][j] = i * NL + j;
            if (((i - li) == (((i - li) / k1i) * k1i)) &&
                (((i - li) / k1i) >= 0) &&
                (((i - li) / k1i) < BN1))
            {
                ib = (i - li) / k1i;
                if (B1[ib] != ib)
                    if (erri > i) erri = i;
            }
        }
    #pragma dvm parallel([i] on B1[i]) reduction(sum(s))
    for (i = 0; i < BN1; i++)
        s = s + B1[i];
    }
    #pragma dvm get_actual(erri, s)

    cs = (0 + BN1-1) * BN1 / 2;
    if ((erri == ER) && (s == cs))
        ansyes(tname);
    else
        ansno(tname);
    #undef AN1
    #undef AN2
    #undef BN1
}
/* ---------------------------------------------ALIGN241  */
/*  ALIGN arrB[i][j][][] WITH arrA[i][j]
                     matrix compression*/
void align241()
{
/*    parameters for ALIGN arrB[i][j][][] WITH arrA[k1i*i+li][k2j*j+lj]*/
    #define AN1 5
    #define AN2 5
    #define BN1 2
    #define BN2 2
    #define BN3 2
    #define BN4 2
    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 0;
    int k1j = 0, k2j = 1, k3j = 0, k4j = 0, lj = 0;

    #pragma dvm array distribute[block][block]
    int A2[AN1][AN2];
    #pragma dvm array align([i][j][][] with A2[k1i*i+li][k2j*j+lj])
    int B4[BN1][BN2][BN3][BN4];
    char tname[] = "align241 ";

    erri = ER;
    s = 0;

    #pragma dvm actual(erri, s)
    #pragma dvm region local(A2, B4)
    {
    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                    B4[i][j][n][m] = 0;
    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb, n, m, nb, mb)
    for (i = 0; i < AN1; i++)
        for (j = 0; j < AN2; j++)
        {
            A2[i][j] = i * NL / 10 + j;
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                {
                    if (((i - li) == (((i - li) / k1i) * k1i)) &&
                        ((j - lj) == (((j - lj) / k2j) * k2j)) &&
                        (((i - li) / k1i) >= 0) &&
                        (((j - lj) / k2j) >= 0) &&
                        (((i - li) / k1i) < BN1) &&
                        (((j - lj) / k2j) < BN2))
                    {
                        ib = (i - li) / k1i;
                        jb = (j - lj) / k2j;
                        nb = n;
                        mb = m;
                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
                    }
                }
        }

    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                {
                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
                    s = s + B4[i][j][n][m];
                    if (B4[i][j][n][m] != val)
                        if (erri > val) erri = val;
                }

    }
    #pragma dvm get_actual(erri, s)

    cs = 0;
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
    if ((erri == ER) && (s == cs))
        ansyes(tname);
    else
        ansno(tname);
    #undef AN1
    #undef AN2
    #undef BN1
    #undef BN2
    #undef BN3
    #undef BN4
}
/* ---------------------------------------------ALIGN2421*/
/*  ALIGN arrB[][i][][j] WITH arrA[j+4][2*i] matrix compression*/
void align2421()
{
/*    parameters for ALIGN arrB[][i][][j] WITH arrA[k2i*j+li][k1j*i+lj]*/
    #define AN1 12
    #define AN2 9
    #define BN1 4
    #define BN2 4
    #define BN3 4
    #define BN4 4
    int k1i = 0, k2i = 1, k3i = 0, k4i = 0, li = 4;
    int k1j = 2, k2j = 0, k3j = 0, k4j = 0, lj = 0;

    #pragma dvm array distribute[block][block]
    int A2[AN1][AN2];
    #pragma dvm array align([][i][][j] with A2[k2i*j+li][k1j*i+lj])
    int B4[BN1][BN2][BN3][BN4];
    char tname[] = "align2421";

    erri = ER;
    s = 0;

    #pragma dvm actual(erri, s)
    #pragma dvm region local(A2, B4)
    {
    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                    B4[i][j][n][m] = 0;
    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb, n, m, nb, mb)
    for (i = 0; i < AN1; i++)
        for (j = 0; j < AN2; j++)
        {
            A2[i][j] = i * NL / 10 + j;
            for (n = 0; n < BN1; n++)
                for (m = 0; m < BN3; m++)
                {
                    if (((i - li) == (((i - li) / k2i) * k2i)) &&
                        ((j - lj) == (((j - lj) / k1j) * k1j)) &&
                        (((i - li) / k2i) >= 0) &&
                        (((j - lj) / k1j) >= 0) &&
                        (((i - li) / k2i) < BN4) &&
                        (((j - lj) / k1j) < BN2))
                    {
                        ib = n;
                        jb = (j - lj) / k1j;
                        nb = m;
                        mb = (i - li) / k2i;
                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
                    }
                }
        }

    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                {
                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
                    s = s + B4[i][j][n][m];
                    if (B4[i][j][n][m] != val)
                        if (erri > val) erri = val;
                }

    }
    #pragma dvm get_actual(erri, s)

    cs = 0;
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
    if ((erri == ER) && (s == cs))
        ansyes(tname);
    else
        ansno(tname);
    #undef AN1
    #undef AN2
    #undef BN1
    #undef BN2
    #undef BN3
    #undef BN4
}
/* ---------------------------------------------ALIGN2422*/
/*  ALIGN arrB[][i][][j] WITH arrA[j+1][2*i] small array*/
void align2422()
{
/*    parameters for ALIGN arrB[][i][][j] WITH arrA[k2i*j+li][k1j*i+lj]*/
    #define AN1 3
    #define AN2 4
    #define BN1 2
    #define BN2 2
    #define BN3 2
    #define BN4 2
    int k1i = 0, k2i = 1, k3i = 0, k4i = 0, li = 1;
    int k1j = 2, k2j = 0, k3j = 0, k4j = 0, lj = 0;

    #pragma dvm array distribute[block][block]
    int A2[AN1][AN2];
    #pragma dvm array align([][i][][j] with A2[k2i*j+li][k1j*i+lj])
    int B4[BN1][BN2][BN3][BN4];
    char tname[] = "align2422";

    erri = ER;
    s = 0;

    #pragma dvm actual(erri, s)
    #pragma dvm region local(A2, B4)
    {
    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                    B4[i][j][n][m] = 0;
    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb, n, m, nb, mb)
    for (i = 0; i < AN1; i++)
        for (j = 0; j < AN2; j++)
        {
            A2[i][j] = i * NL / 10 + j;
            for (n = 0; n < BN1; n++)
                for (m = 0; m < BN3; m++)
                {
                    if (((i - li) == (((i - li) / k2i) * k2i)) &&
                        ((j - lj) == (((j - lj) / k1j) * k1j)) &&
                        (((i - li) / k2i) >= 0) &&
                        (((j - lj) / k1j) >= 0) &&
                        (((i - li) / k2i) < BN4) &&
                        (((j - lj) / k1j) < BN2))
                    {
                        ib = n;
                        jb = (j - lj) / k1j;
                        nb = m;
                        mb = (i - li) / k2i;
                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
                    }
                }
        }

    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                {
                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
                    s = s + B4[i][j][n][m];
                    if (B4[i][j][n][m] != val)
                        if (erri > val) erri = val;
                }

    }
    #pragma dvm get_actual(erri, s)

    cs = 0;
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
    if ((erri == ER) && (s == cs))
        ansyes(tname);
    else
        ansno(tname);
    #undef AN1
    #undef AN2
    #undef BN1
    #undef BN2
    #undef BN3
    #undef BN4
}
/* ---------------------------------------------ALIGN243*/
/*  ALIGN arrB[][][i][] WITH arrA[1][i] matrix compression
                                        and replication*/
void align243()
{
/*  parameters for ALIGN arrB[][][i][] WITH arrA[li][k1j*i+lj]*/
    #define AN1 3
    #define AN2 4
    #define BN1 2
    #define BN2 2
    #define BN3 2
    #define BN4 2
    int k1i = 0, k2i = 0, k3i = 0, k4i = 0, li = 1;
    int k1j = 1, k2j = 0, k3j = 0, k4j = 0, lj = 0;

    #pragma dvm array distribute[block][block]
    int A2[AN1][AN2];
    #pragma dvm array align([][][i][] with A2[li][k1j*i+lj])
    int B4[BN1][BN2][BN3][BN4];
    char tname[] = "align243 ";

    erri = ER;
    s = 0;

    #pragma dvm actual(erri, s)
    #pragma dvm region local(A2, B4)
    {
    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                    B4[i][j][n][m] = 0;
    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb, k, n, m, nb, mb)
    for (i = 0; i < AN1; i++)
        for (j = 0; j < AN2; j++)
        {
            A2[i][j] = i * NL / 10 + j;
            if (i == li)
                for (n = 0; n < BN1; n++)
                    for (m = 0; m < BN2; m++)
                        for (k = 0; k < BN4; k++)
                        {
                            if (((j - lj) == (((j - lj) / k1j) * k1j)) &&
                                (((j - lj) / k1j) >= 0) &&
                                (((j - lj) / k1j) < BN3))
                            {
                                ib = n;
                                jb = m;
                                nb = ((j - lj) / k1j);
                                mb = k;
                                B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
                            }
                        }
        }

    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                {
                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
                    s = s + B4[i][j][n][m];
                    if (B4[i][j][n][m] != val)
                        if (erri > val) erri = val;
                }

    }
    #pragma dvm get_actual(erri, s)

    cs = 0;
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
    if ((erri == ER) && (s == cs))
        ansyes(tname);
    else
        ansno(tname);
    #undef AN1
    #undef AN2
    #undef BN1
    #undef BN2
    #undef BN3
    #undef BN4
}
/* ---------------------------------------------ALIGN244*/
/*  ALIGN arrB[][][][i] WITH arrA[i][]  matrix compression
                                    and replication*/
void align244()
{
/*    parameters for ALIGN arrB[][][i][] WITH arrA[k1i*i+li][]*/
    #define AN1 12
    #define AN2 9
    #define BN1 4
    #define BN2 4
    #define BN3 4
    #define BN4 4
    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 0;
    int k1j = 0, k2j = 0, k3j = 0, k4j = 0, lj = 0;

    #pragma dvm array distribute[block][block]
    int A2[AN1][AN2];
    #pragma dvm array align([][][i][] with A2[k1i * i + li][])
    int B4[BN1][BN2][BN3][BN4];
    char tname[] = "align244 ";

    erri = ER;
    s = 0;

    #pragma dvm actual(erri, s)
    #pragma dvm region local(A2, B4)
    {
    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
    for (i = 0; i < BN1; i++)
        for (j = 0; j < BN2; j++)
            for (n = 0; n < BN3; n++)
                for (m = 0; m < BN4; m++)
                    B4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
    #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), private(ib, jb, m, n, k, nb, mb)
    for (i = 0; i < AN1; i++)
        for (j = 0; j < AN2; j++)
        {
            A2[i][j] = i * NL / 10 + j;
            for (n = 0; n < BN1; n++)
                for (m = 0; m < BN2; m++)
                    for (k = 0; k < BN4; k++)
                    {
                        if (((i - li) == (((i - li) / k1i) * k1i)) &&
                            (((i - li) / k1i) >= 0) &&
                            (((i - li) / k1i) < BN3))
                        {
                            int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
                            ib = n;
                            jb = m;
                            nb = ((i - li) / k1i);
                            mb = k;
                            if (B4[ib][jb][nb][mb] != ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb)
                                if (erri > val) erri = val;
                        }
                    }
        }

    }
    #pragma dvm get_actual(erri, s)

    cs = 0;
    if ((erri == ER) && (s == cs))
        ansyes(tname);
    else
        ansno(tname);
    #undef AN1
    #undef AN2
    #undef BN1
    #undef BN2
    #undef BN3
    #undef BN4
}

void ansyes(const char name[])
{
    printf("%s  -  complete\n", name);
}

void ansno(const char name[])
{
    printf("%s  -  ***error\n", name);
}
