iced | High performance and correct x86

typedef struct
{
    char foodCategory[15],foodName1[30],foodName2[30],foodName3[30];
    double foodPrice1,foodPrice2,foodPrice3;
}Food;

void print_food()
{
    Food c[300];
    int lineNumber = 2,index = 1;
  
    FILE *file = fopen("Food.txt","r");

    if (file != NULL)
    {
        char line[300];
        while (fgets(line, sizeof line, file) != NULL)
        {
            if (index == lineNumber)
            {
                sscanf(line,"%14s-%29s %lf %29s %lf %29s %lf",
                       c[lineNumber].foodCategory,
                       c[lineNumber].foodName1,
                       c[lineNumber].foodPrice1,
                       c[lineNumber].foodName2,
                       c[lineNumber].foodPrice2,
                       c[lineNumber].foodName3,
                       c[lineNumber].foodPrice3);
                printf("---%s---\n",c[lineNumber].foodCategory);
                printf("%s\t%lf\n", c[lineNumber].foodName1,c[lineNumber].foodPrice1);
                printf("%s\t%lf\n", c[lineNumber].foodName2,c[lineNumber].foodPrice2);
                printf("%s\t%lf\n", c[lineNumber].foodName3,c[lineNumber].foodPrice3);
            }
            else
            {
                index++;
            }
        }
        fclose(file);
    }
    else
    {
        printf("No file found");
    }
}

// iced-x86 features needed: --features "decoder nasm"
const { Decoder, DecoderOptions, Formatter, FormatterSyntax } = require("iced-x86");

/*
This code produces the following output:
00007FFAC46ACDA4 48895C2410           mov       [rsp+10h],rbx
00007FFAC46ACDA9 4889742418           mov       [rsp+18h],rsi
00007FFAC46ACDAE 55                   push      rbp
00007FFAC46ACDAF 57                   push      rdi
00007FFAC46ACDB0 4156                 push      r14
00007FFAC46ACDB2 488DAC2400FFFFFF     lea       rbp,[rsp-100h]
00007FFAC46ACDBA 4881EC00020000       sub       rsp,200h
00007FFAC46ACDC1 488B0518570A00       mov       rax,[rel 7FFA`C475`24E0h]
00007FFAC46ACDC8 4833C4               xor       rax,rsp
00007FFAC46ACDCB 488985F0000000       mov       [rbp+0F0h],rax
00007FFAC46ACDD2 4C8B052F240A00       mov       r8,[rel 7FFA`C474`F208h]
00007FFAC46ACDD9 488D05787C0400       lea       rax,[rel 7FFA`C46F`4A58h]
00007FFAC46ACDE0 33FF                 xor       edi,edi
*/

const exampleBitness = 64;
const exampleRipLo = 0xC46ACDA4;
const exampleRipHi = 0x00007FFA;
const exampleCode = new Uint8Array([
    0x48, 0x89, 0x5C, 0x24, 0x10, 0x48, 0x89, 0x74, 0x24, 0x18, 0x55, 0x57, 0x41, 0x56, 0x48, 0x8D,
    0xAC, 0x24, 0x00, 0xFF, 0xFF, 0xFF, 0x48, 0x81, 0xEC, 0x00, 0x02, 0x00, 0x00, 0x48, 0x8B, 0x05,
    0x18, 0x57, 0x0A, 0x00, 0x48, 0x33, 0xC4, 0x48, 0x89, 0x85, 0xF0, 0x00, 0x00, 0x00, 0x4C, 0x8B,
    0x05, 0x2F, 0x24, 0x0A, 0x00, 0x48, 0x8D, 0x05, 0x78, 0x7C, 0x04, 0x00, 0x33, 0xFF
]);
const hexBytesColumnByteLength = 10;

const decoder = new Decoder(exampleBitness, exampleCode, DecoderOptions.None);
// You have to enable the bigint feature to get i64/u64 APIs, not all browsers support BigInt
decoder.ipLo = exampleRipLo;
decoder.ipHi = exampleRipHi;
// This decodes all bytes. There's also `decode()` which decodes the next instruction,
// `decodeInstructions(count)` which decodes `count` instructions and `decodeOut(instruction)`
// which overwrites an existing instruction.
const instructions = decoder.decodeAll();

// Create a nasm formatter. It supports: Masm, Nasm, Gas (AT&T) and Intel (XED).
// There's also `FastFormatter` which uses less code (smaller wasm files).
//     const formatter = new FastFormatter();
const formatter = new Formatter(FormatterSyntax.Nasm);

// Change some options, there are many more
formatter.digitSeparator = "`";
formatter.firstOperandCharIndex = 10;

// Format the instructions
instructions.forEach(instruction => {
    const disasm = formatter.format(instruction);

    // Eg. "00007FFAC46ACDB2 488DAC2400FFFFFF     lea       rbp,[rsp-100h]"
    let line = ("0000000" + instruction.ipHi.toString(16)).substr(-8).toUpperCase() +
               ("0000000" + instruction.ipLo.toString(16)).substr(-8).toUpperCase();
    line += " ";
    const startIndex = instruction.ipLo - exampleRipLo;
    exampleCode.slice(startIndex, startIndex + instruction.length).forEach(b => {
        line += ("0" + b.toString(16)).substr(-2).toUpperCase();
    });
    for (let i = instruction.length; i < hexBytesColumnByteLength; i++)
        line += "  ";
    line += " ";
    line += disasm;

    console.log(line);
});