test/test_fp8_arithmetics_YYY.c.in

/*
    Licensed to the Apache Software Foundation (ASF) under one
    or more contributor license agreements.  See the NOTICE file
    distributed with this work for additional information
    regarding copyright ownership.  The ASF licenses this file
    to you under the Apache License, Version 2.0 (the
    "License"); you may not use this file except in compliance
    with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing,
    software distributed under the License is distributed on an
    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, either express or implied.  See the License for the
    specific language governing permissions and limitations
    under the License.
*/
/**
 * @file test_fp8_arithmetics_YYY.c
 * @author Samuele Andreoli
 * @brief Test for aritmetics with FP8_YYY
 *
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "arch.h"
#include "amcl.h"
#include "utils.h"
#include "fp8_YYY.h"

#define LINE_LEN 10000
#define MAX_STRING 300

void read_BIG_XXX(BIG_XXX A, char* string)
{
    int len;
    char support[LINE_LEN];
    len = strlen(string)+1;
    amcl_hex2bin(string,support,len);
    len = (len-1)/2;
    BIG_XXX_fromBytesLen(A,support,len);
    BIG_XXX_norm(A);
}

void read_FP2_YYY(FP2_YYY *fp2, char* stringx)
{
    char *stringy, *end;
    BIG_XXX x,y;

    stringy = strchr(++stringx,',');
    if (stringy == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    *stringy = '\0';

    end = strchr(++stringy,']');
    if (end == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    *end = '\0';

    read_BIG_XXX(x,stringx);
    read_BIG_XXX(y,stringy);

    FP2_YYY_from_BIGs(fp2,x,y);
}

void read_FP4_YYY(FP4_YYY *fp4, char* stringx)
{
    char *stringy, *end;
    FP2_YYY x,y;

    stringy = strchr(++stringx,']');
    if (stringy == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    *(++stringy) = '\0';

    end = strchr(++stringy,']');
    if (end == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    *(++end) = '\0';

    read_FP2_YYY(&x,stringx);
    read_FP2_YYY(&y,stringy);

    FP4_YYY_from_FP2s(fp4,&x,&y);
}

void read_FP8_YYY(FP8_YYY *fp8, char* stringx)
{
    char *stringy, *end;
    FP4_YYY x,y;

    stringy = strchr(++stringx, ']');
    if (stringy == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    stringy = strchr(++stringy, ']');
    if (stringy == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    stringy+=2;
    *(stringy)=0;

    end = strchr(++stringy, ']');
    if (end == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    end = strchr(++end, ']');
    if (end == NULL)
    {
        printf("ERROR unexpected test vector\n");
        exit(EXIT_FAILURE);
    }
    end+=2;
    *(end)=0;

    read_FP4_YYY(&x,stringx);
    read_FP4_YYY(&y,stringy);

    FP8_YYY_from_FP4s(fp8,&x,&y);
}

int main(int argc, char** argv)
{
    if (argc != 2)
    {
        printf("usage: ./test_fp4_arithmetics_YYY [path to test vector file]\n");
        exit(EXIT_FAILURE);
    }

    int i = 0, len = 0, j = 0;
    FILE *fp;

    char line[LINE_LEN];
    char * linePtr = NULL;

    FP8_YYY FP8aux1, FP8aux2, FP8aux3, FP8aux4;

    FP8_YYY FP8_1;
    const char* FP8_1line = "FP8_1 = ";
    FP8_YYY FP8_2;
    const char* FP8_2line = "FP8_2 = ";
    FP8_YYY FP8add;
    const char* FP8addline = "FP8add = ";
    FP8_YYY FP8neg;
    const char* FP8negline = "FP8neg = ";
    FP8_YYY FP8sub;
    const char* FP8subline = "FP8sub = ";
    FP8_YYY FP8conj;
    const char* FP8conjline = "FP8conj = ";
    FP8_YYY FP8nconj;
    const char* FP8nconjline = "FP8nconj = ";
    FP4_YYY FP4sc;
    const char* FP4scline = "FP4sc = ";
    FP8_YYY FP8pmul;
    const char* FP8pmulline = "FP8pmul = ";
    FP2_YYY FP2sc;
    const char* FP2scline = "FP2sc = ";
    FP8_YYY FP8qmul;
    const char* FP8qmulline = "FP8qmul = ";
    BIG_XXX bigFPsc;
    FP_YYY FPsc;
    const char* FPscline = "FPsc = ";
    FP8_YYY FP8tmul;
    const char* FP8tmulline = "FP8tmul = ";
    FP8_YYY FP8imul;
    const char* FP8imulline = "FP8imul = ";
    FP8_YYY FP8sqr;
    const char* FP8sqrline = "FP8sqr = ";
    FP8_YYY FP8mul;
    const char* FP8mulline = "FP8mul = ";
    FP8_YYY FP8inv;
    const char* FP8invline = "FP8inv = ";
    FP8_YYY FP8mulj;
    const char* FP8muljline = "FP8mulj = ";
    BIG_XXX BIGsc1;
    const char* BIGsc1line = "BIGsc1 = ";
    BIG_XXX BIGsc2;
    const char* BIGsc2line = "BIGsc2 = ";
    FP8_YYY FP8pow;
    const char* FP8powline = "FP8pow = ";
#if CURVE_SECURITY_ZZZ == 192
    FP8_YYY FP24traces[4];
    const char* FP24_1line = "FP24_1 = ";
    const char* FP24_2line = "FP24_2 = ";
    const char* FP24_3line = "FP24_3 = ";
    const char* FP24_4line = "FP24_4 = ";
    FP8_YYY FP8_xtrA;
    const char* FP8_xtrAline = "FP8_xtrA = ";
    FP8_YYY FP8_xtrD;
    const char* FP8_xtrDline = "FP8_xtrD = ";
    FP8_YYY FP8_xtrpow;
    const char* FP8_xtrpowline = "FP8_xtrpow = ";
    FP8_YYY FP8_xtrpow2;
    const char* FP8_xtrpow2line = "FP8_xtrpow2 = ";
#elif CURVE_SECURITY_ZZZ == 256
    FP8_YYY FP8sqrt;
    const char* FP8sqrtline = "FP8sqrt = ";
    FP8_YYY FP8divi;
    const char* FP8diviline = "FP8divi = ";
    FP8_YYY FP8divi2;
    const char* FP8divi2line = "FP8divi2 = ";
    FP8_YYY FP8div2i;
    const char* FP8div2iline = "FP8div2i = ";
#endif

    // Set to zero and one
    FP8_YYY_zero(&FP8aux1);
    FP8_YYY_zero(&FP8aux2);

    // Testing equal function and set zero function
    if(!FP8_YYY_equals(&FP8aux1,&FP8aux2) || !FP8_YYY_iszilch(&FP8aux1) || !FP8_YYY_isreal(&FP8aux1))
    {
        printf("ERROR comparing FP8s or setting FP8 to zero FP\n");
        exit(EXIT_FAILURE);
    }

    // Set to one
    FP8_YYY_one(&FP8aux1);

    // Testing equal function and set one function
    if(FP8_YYY_equals(&FP8aux1,&FP8aux2) || !FP8_YYY_isunity(&FP8aux1) || FP8_YYY_isunity(&FP8aux2) || FP8_YYY_iszilch(&FP8aux1) || !FP8_YYY_isreal(&FP8aux1))
    {
        printf("ERROR comparing FP8s or setting FP8 to unity FP\n");
        exit(EXIT_FAILURE);
    }


    fp = fopen(argv[1], "r");
    if (fp == NULL)
    {
        printf("ERROR opening test vector file\n");
        exit(EXIT_FAILURE);
    }

    while (fgets(line, LINE_LEN, fp) != NULL)
    {
        i++;
        // Read first FP8 and perform some tests
        if (!strncmp(line,FP8_1line, strlen(FP8_1line)))
        {
            len = strlen(FP8_1line);
            linePtr = line + len;
            read_FP8_YYY(&FP8_1,linePtr);
            // test FP8_from_FP4s
            FP8_YYY_from_FP4s(&FP8aux1,&FP8_1.a,&FP8_1.b);
            if(!FP8_YYY_equals(&FP8aux1,&FP8_1))
            {
                printf("ERROR in generating FP8 from two FP4s, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            // test FP8_from_FP4
            FP8_YYY_from_FP4(&FP8aux1,&FP8_1.a);
            FP8_YYY_copy(&FP8aux2,&FP8_1);
            FP4_YYY_zero(&FP8aux2.b);
            if(!FP8_YYY_equals(&FP8aux1,&FP8aux2))
            {
                printf("ERROR in generating FP8 from one FP4, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            // test FP8_from_FP4
            FP8_YYY_from_FP4H(&FP8aux1,&FP8_1.b);
            FP8_YYY_copy(&FP8aux2,&FP8_1);
            FP4_YYY_zero(&FP8aux2.a);
            if(!FP8_YYY_equals(&FP8aux1,&FP8aux2))
            {
                printf("ERROR in generating FP8 from one FP4 as high part, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Read second FP8
        if (!strncmp(line,FP8_2line, strlen(FP8_2line)))
        {
            len = strlen(FP8_2line);
            linePtr = line + len;
            read_FP8_YYY(&FP8_2,linePtr);
        }
        // Addition test
        if (!strncmp(line,FP8addline, strlen(FP8addline)))
        {
            len = strlen(FP8addline);
            linePtr = line + len;
            read_FP8_YYY(&FP8add,linePtr);
            FP8_YYY_copy(&FP8aux1,&FP8_1);
            FP8_YYY_copy(&FP8aux2,&FP8_2);
            FP8_YYY_add(&FP8aux1,&FP8aux1,&FP8aux2);
            // test commutativity P+Q = Q+P
            FP8_YYY_copy(&FP8aux3,&FP8_1);
            FP8_YYY_add(&FP8aux2,&FP8aux2,&FP8aux3);
            if(!FP8_YYY_equals(&FP8aux1,&FP8add) || !FP8_YYY_equals(&FP8aux2,&FP8add))
            {
                printf("ERROR adding two FP8, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            // test associativity (P+Q)+R = P+(Q+R)
            FP8_YYY_copy(&FP8aux1,&FP8_1);
            FP8_YYY_copy(&FP8aux3,&FP8_1);
            FP8_YYY_copy(&FP8aux2,&FP8_2);
            FP8_YYY_copy(&FP8aux4,&FP8add);
            FP8_YYY_add(&FP8aux1,&FP8aux1,&FP8aux2);
            FP8_YYY_add(&FP8aux1,&FP8aux1,&FP8aux4);
            FP8_YYY_add(&FP8aux2,&FP8aux2,&FP8aux4);
            FP8_YYY_add(&FP8aux2,&FP8aux2,&FP8aux3);
            FP8_YYY_reduce(&FP8aux1);
            FP8_YYY_norm(&FP8aux2);
            if(!FP8_YYY_equals(&FP8aux1,&FP8aux2))
            {
                printf("ERROR testing associativity between three FP8s, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Test negative of an FP8
        if (!strncmp(line,FP8negline, strlen(FP8negline)))
        {
            len = strlen(FP8negline);
            linePtr = line + len;
            read_FP8_YYY(&FP8neg,linePtr);
            FP8_YYY_copy(&FP8aux1,&FP8_1);
            FP8_YYY_neg(&FP8aux1,&FP8aux1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8neg))
            {
                printf("ERROR in computing negative of FP8, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Subtraction test
        if (!strncmp(line,FP8subline, strlen(FP8subline)))
        {
            len = strlen(FP8subline);
            linePtr = line + len;
            read_FP8_YYY(&FP8sub,linePtr);
            FP8_YYY_copy(&FP8aux1,&FP8_1);
            FP8_YYY_copy(&FP8aux2,&FP8_2);
            FP8_YYY_sub(&FP8aux1,&FP8aux1,&FP8aux2);
            if(FP8_YYY_equals(&FP8aux1,&FP8sub) == 0)
            {
                printf("ERROR subtraction between two FP8, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Test conjugate
        if (!strncmp(line,FP8conjline, strlen(FP8conjline)))
        {
            len = strlen(FP8conjline);
            linePtr = line + len;
            read_FP8_YYY(&FP8conj,linePtr);
            FP8_YYY_copy(&FP8aux1,&FP8_1);
            FP8_YYY_conj(&FP8aux1,&FP8aux1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8conj))
            {
                printf("ERROR computing conjugate of FP8, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Test negative conjugate
        if (!strncmp(line,FP8nconjline, strlen(FP8nconjline)))
        {
            len = strlen(FP8nconjline);
            linePtr = line + len;
            read_FP8_YYY(&FP8nconj,linePtr);
            FP8_YYY_copy(&FP8aux1,&FP8_1);
            FP8_YYY_nconj(&FP8aux1,&FP8aux1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8nconj))
            {
                printf("ERROR computing negative conjugate of FP8, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Read FP4 scalar
        if (!strncmp(line,FP4scline, strlen(FP4scline)))
        {
            len = strlen(FP4scline);
            linePtr = line + len;
            read_FP4_YYY(&FP4sc,linePtr);
        }
        // Read FP2 scalar
        if (!strncmp(line,FP2scline, strlen(FP2scline)))
        {
            len = strlen(FP2scline);
            linePtr = line + len;
            read_FP2_YYY(&FP2sc,linePtr);
        }
        // Read FP scalar
        if (!strncmp(line,FPscline, strlen(FPscline)))
        {
            len = strlen(FPscline);
            linePtr = line + len;
            read_BIG_XXX(bigFPsc,linePtr);
            FP_YYY_nres(&FPsc,bigFPsc);
        }
        // Multiplication by FP4
        if (!strncmp(line,FP8pmulline, strlen(FP8pmulline)))
        {
            len = strlen(FP8pmulline);
            linePtr = line + len;
            read_FP8_YYY(&FP8pmul,linePtr);
            FP8_YYY_pmul(&FP8aux1,&FP8_1,&FP4sc);
            if(!FP8_YYY_equals(&FP8aux1,&FP8pmul))
            {
                printf("ERROR in multiplication by FP4, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Multiplication by FP2
        if (!strncmp(line,FP8qmulline, strlen(FP8qmulline)))
        {
            len = strlen(FP8qmulline);
            linePtr = line + len;
            read_FP8_YYY(&FP8qmul,linePtr);
            FP8_YYY_qmul(&FP8aux1,&FP8_1,&FP2sc);
            if(!FP8_YYY_equals(&FP8aux1,&FP8qmul))
            {
                printf("ERROR in multiplication by FP2, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Multiplication by FP
        if (!strncmp(line,FP8tmulline, strlen(FP8tmulline)))
        {
            len = strlen(FP8tmulline);
            linePtr = line + len;
            read_FP8_YYY(&FP8tmul,linePtr);
            FP8_YYY_tmul(&FP8aux1,&FP8_1,&FPsc);
            if(!FP8_YYY_equals(&FP8aux1,&FP8tmul))
            {
                printf("ERROR in multiplication by FP, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Multiplication by j = 0..10
        if (!strncmp(line,FP8imulline, strlen(FP8imulline)))
        {
            len = strlen(FP8imulline);
            linePtr = line + len;
            read_FP8_YYY(&FP8imul,linePtr);
            FP8_YYY_imul(&FP8aux1,&FP8_1,j);
            j++;
            if(!FP8_YYY_equals(&FP8aux1,&FP8imul))
            {
                printf("ERROR in multiplication by small integer, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Square test
        if (!strncmp(line,FP8sqrline, strlen(FP8sqrline)))
        {
            len = strlen(FP8sqrline);
            linePtr = line + len;
            read_FP8_YYY(&FP8sqr,linePtr);
            FP8_YYY_sqr(&FP8aux1,&FP8_1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8sqr))
            {
                printf("ERROR in squaring FP8, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Multiplication between two FP8s
        if (!strncmp(line,FP8mulline, strlen(FP8mulline)))
        {
            len = strlen(FP8mulline);
            linePtr = line + len;
            read_FP8_YYY(&FP8mul,linePtr);
            FP8_YYY_mul(&FP8aux1,&FP8_1,&FP8_2);
            if(!FP8_YYY_equals(&FP8aux1,&FP8mul))
            {
                printf("ERROR in multiplication between two FP8s, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Inverse
        if (!strncmp(line,FP8invline, strlen(FP8invline)))
        {
            len = strlen(FP8invline);
            linePtr = line + len;
            read_FP8_YYY(&FP8inv,linePtr);
            FP8_YYY_inv(&FP8aux1,&FP8_1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8inv))
            {
                printf("ERROR in computing inverse of FP8, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Test multiplication of an FP8 instance by sqrt(sqrt(1+sqrt(-1)))
        if (!strncmp(line,FP8muljline, strlen(FP8muljline)))
        {
            len = strlen(FP8muljline);
            linePtr = line + len;
            read_FP8_YYY(&FP8mulj,linePtr);
            FP8_YYY_copy(&FP8aux1,&FP8_1);
            FP8_YYY_times_i(&FP8aux1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8mulj))
            {
                printf("ERROR in  multiplication of an FP8 instance by sqrt(sqrt(1+sqrt(-1))), line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Read exponent
        if (!strncmp(line,BIGsc1line, strlen(BIGsc1line)))
        {
            len = strlen(BIGsc1line);
            linePtr = line + len;
            read_BIG_XXX(BIGsc1,linePtr);
        }
        if (!strncmp(line,BIGsc2line, strlen(BIGsc2line)))
        {
            len = strlen(BIGsc2line);
            linePtr = line + len;
            read_BIG_XXX(BIGsc2,linePtr);
        }
        // Raise FP8 by BIG power
        if (!strncmp(line,FP8powline, strlen(FP8powline)))
        {
            len = strlen(FP8powline);
            linePtr = line + len;
            read_FP8_YYY(&FP8pow,linePtr);
            FP8_YYY_pow(&FP8aux1,&FP8_1,BIGsc1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8pow))
            {
                printf("ERROR in raising FP8 by BIG power, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#if CURVE_SECURITY_ZZZ == 192
        // Read first FP24 trace
        if (!strncmp(line,FP24_1line, strlen(FP24_1line)))
        {
            len = strlen(FP24_1line);
            linePtr = line + len;
            read_FP8_YYY(FP24traces,linePtr);
        }
        // Read second FP24 trace
        if (!strncmp(line,FP24_2line, strlen(FP24_2line)))
        {
            len = strlen(FP24_2line);
            linePtr = line + len;
            read_FP8_YYY(FP24traces+1,linePtr);
        }
        // Read third FP24 trace
        if (!strncmp(line,FP24_3line, strlen(FP24_3line)))
        {
            len = strlen(FP24_3line);
            linePtr = line + len;
            read_FP8_YYY(FP24traces+2,linePtr);
        }
        // Read fourth FP24 trace
        if (!strncmp(line,FP24_4line, strlen(FP24_4line)))
        {
            len = strlen(FP24_4line);
            linePtr = line + len;
            read_FP8_YYY(FP24traces+3,linePtr);
        }
        // Test the XTR addition function r=w*x-conj(x)*y+z
        if (!strncmp(line,FP8_xtrAline, strlen(FP8_xtrAline)))
        {
            len = strlen(FP8_xtrAline);
            linePtr = line + len;
            read_FP8_YYY(&FP8_xtrA,linePtr);
            FP8_YYY_xtr_A(&FP8aux1,&FP8_1,&FP8_2,&FP8add,&FP8sub);
            if(!FP8_YYY_equals(&FP8aux1,&FP8_xtrA))
            {
                printf("ERROR in testing the XTR addition function r=w*x-conj(x)*y+z, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Test the XTR doubling function r=x^2-2*conj(x)
        if (!strncmp(line,FP8_xtrDline, strlen(FP8_xtrDline)))
        {
            len = strlen(FP8_xtrDline);
            linePtr = line + len;
            read_FP8_YYY(&FP8_xtrD,linePtr);
            FP8_YYY_xtr_D(&FP8aux1,&FP8_1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8_xtrD))
            {
                printf("ERROR in testing the XTR doubling function r=x^2-2*conj(x), line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        // Calculates FP8 trace of an FP24 raised to the power of a BIG number
        if (!strncmp(line,FP8_xtrpowline, strlen(FP8_xtrpowline)))
        {
            len = strlen(FP8_xtrpowline);
            linePtr = line + len;
            read_FP8_YYY(&FP8_xtrpow,linePtr);
            FP8_YYY_xtr_pow(&FP8aux1,FP24traces,BIGsc1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8_xtrpow))
            {
                printf("ERROR computing FP8 trace of an FP24 raised to the power of a BIG number, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }

        // Calculates FP8 trace of two FP24 raised to the power of two BIG numbers
        if (!strncmp(line,FP8_xtrpow2line, strlen(FP8_xtrpow2line)))
        {
            len = strlen(FP8_xtrpow2line);
            linePtr = line + len;
            read_FP8_YYY(&FP8_xtrpow2,linePtr);
            FP8_YYY_xtr_pow2(&FP8aux1,FP24traces+1,FP24traces,FP24traces+2,FP24traces+3,BIGsc2,BIGsc1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8_xtrpow2))
            {
                printf("ERROR computing FP8 trace of an FP24 raised to the power of a BIG number (Double), line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#elif CURVE_SECURITY_ZZZ == 256
        if(!strncmp(line,FP8sqrtline, strlen(FP8sqrtline)))
        {
            len = strlen(FP8sqrtline);
            linePtr = line + len;
            read_FP8_YYY(&FP8sqrt,linePtr);
            FP8_YYY_sqrt(&FP8aux1,&FP8_1);
            FP8_YYY_sqr(&FP8aux2,&FP8aux1);
            if(!FP8_YYY_equals(&FP8aux2,&FP8_1))
            {
                printf("ERROR consistency FP8_YYY_sqr and FP8_YYY_sqrt, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            FP8_YYY_neg(&FP8aux2,&FP8aux1);
            if(!(FP8_YYY_equals(&FP8aux1,&FP8sqrt) || FP8_YYY_equals(&FP8aux2,&FP8sqrt)))
            {
                printf("ERROR computing square root of FP8, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        if(!strncmp(line,FP8diviline, strlen(FP8diviline)))
        {
            len = strlen(FP8diviline);
            linePtr = line + len;
            read_FP8_YYY(&FP8divi,linePtr);
            FP8_YYY_copy(&FP8aux1,&FP8_1);
            FP8_YYY_div_i(&FP8aux1);
            FP8_YYY_copy(&FP8aux2,&FP8aux1);
            FP8_YYY_times_i(&FP8aux2);
            if(!FP8_YYY_equals(&FP8aux2,&FP8_1))
            {
                printf("ERROR consistency FP8_YYY_times_i and FP8_YYY_div_i, line %d\n",i);
                exit(EXIT_FAILURE);
            }
            if(!FP8_YYY_equals(&FP8aux1,&FP8divi))
            {
                printf("ERROR dividing FP8 by sqrt(sqrt(1+sqrt(-1))), line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        if(!strncmp(line,FP8divi2line, strlen(FP8divi2line)))
        {
            len = strlen(FP8divi2line);
            linePtr = line + len;
            read_FP8_YYY(&FP8divi2,linePtr);
            FP8_YYY_copy(&FP8aux1,&FP8_1);
            FP8_YYY_div_i2(&FP8aux1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8divi2))
            {
                printf("ERROR dividing FP8 by sqrt(1+sqrt(-1)) twice, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
        if(!strncmp(line,FP8div2iline, strlen(FP8div2iline)))
        {
            len = strlen(FP8div2iline);
            linePtr = line + len;
            read_FP8_YYY(&FP8div2i,linePtr);
            FP8_YYY_copy(&FP8aux1,&FP8_1);
            FP8_YYY_div_2i(&FP8aux1);
            if(!FP8_YYY_equals(&FP8aux1,&FP8div2i))
            {
                printf("ERROR dividing FP8 by sqrt(sqrt(1+sqrt(-1)))/2, line %d\n",i);
                exit(EXIT_FAILURE);
            }
        }
#endif
    }
    fclose(fp);

#if CURVE_SECURITY_ZZZ == 256
    /* Consistency tests for sqrt */

    // Sqrt of 0
    FP8_YYY_zero(&FP8aux1);
    FP8_YYY_output(&FP8aux1);
    printf("\n");

    if(!(FP8_YYY_sqrt(&FP8aux1,&FP8aux1) && FP8_YYY_iszilch(&FP8aux1)))
    {
        printf("ERROR Handling 0 in FP8_YYY_sqrt");
        exit(EXIT_FAILURE);
    }

    // Sqrt of "real" FP8
    // REMARK: Assume FP4sc is set during the TV test
    FP8_YYY_from_FP4(&FP8aux1,&FP4sc);
    FP8_YYY_sqrt(&FP8aux2,&FP8aux1);
    FP8_YYY_sqr(&FP8aux3,&FP8aux2);
    if(!FP8_YYY_equals(&FP8aux1,&FP8aux3))
    {
        printf("ERROR consistency of FP8_YYY_sqrt for real FP8, line %d\n",i);
        exit(EXIT_FAILURE);
    }
#endif

    printf("SUCCESS TEST ARITMETIC OF FP PASSED\n");
    exit(EXIT_SUCCESS);
}