[dcpu16] / as-dcpu16.c

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sysexits.h>
#include <assert.h>

#include "as-dcpu16.h"

/*
 *  quick and dirty assembler for dcpu16
 *  
 */

static const char * const src_id_ = "$Id$";

const char const out_filename_default_[] = "a.out";
unsigned int verbose_ = 0;
unsigned int dryrun_ = 0;


#define DEBUG_NOTIFY(...) do { if (verbose_ > 2) fprintf(stderr, __VA_ARGS__); } while (0)
#define VERBOSE_NOTIFY(...) do { if (verbose_) printf(__VA_ARGS__); } while (0)


static
void usage_(char *prog, unsigned int full) {
    FILE *f = full ? stdout : stderr;
    char *x = strrchr(prog, '/');

    if (x && *(x + 1))
        prog = x + 1;

    if (full)
        fprintf(f, "%s -- \n\n",
                prog);

    fprintf(f, "Usage: %s [-h] [-v] [-s] [-o file] file [file [...]]\n",
            prog);

    if (full) {
        fprintf(f, "\nOptions:\n"
                   "\t-h -- this screen\n"
                   "\t-o <file> -- output to <file> [default: %s]\n"
                   "\t-s -- allow short labels in instruction words\n"
                   "\t-d -- dry run, print results, do not write to file\n"
                   "\t-v -- verbose output\n",
                out_filename_default_);

        fprintf(f, "\n%78s\n",
                src_id_);
    }
}


/* maintain an array of the instructions we have parsed */
static
struct instruction_list_ *instr_list_new(void) {
    size_t init_size = 1024;
    struct instruction_list_ *il = malloc(IL_SIZE(init_size));
    if (il == NULL) {
        fprintf(stderr, "%s():%s\n", "malloc", strerror(errno));
        return NULL;
    }
    il->allocated = init_size;
    il->entries = 0;
    return il;
}

static
int instr_list_insert(struct instruction_list_ **il, struct instruction_ *i) {
    /* make room make room */
    if ((*il)->entries - 1 == (*il)->allocated) {
        size_t new_allocated = (*il)->allocated + 1024;
        void *tmp_ptr = realloc(*il, IL_SIZE(new_allocated));
        if (tmp_ptr == NULL) {
            fprintf(stderr, "%s():%s\n", "realloc", strerror(errno));
            return -1;
        }
        *il = tmp_ptr;
        (*il)->allocated = new_allocated;
    }

    (*il)->instr[(*il)->entries] = i;
    (*il)->entries += 1;
    return 0;
}

/* also maintain a list of the labels we've seen, indexed back to their instructions. */
/* FIXME: ugh, this could all stand to be rewritten cleaner */
/* these lists could be rearranged to be a lot easier to wrangle and/or maybe use common interfaces */
/* they were thrown together on the fly */
static
struct label_list_ *label_list_new(void) {
    size_t init_size = 256;
    struct label_list_ *ll = malloc(LL_SIZE(init_size));
    if (ll == NULL) {
        fprintf(stderr, "%s():%s\n", "malloc", strerror(errno));
        return NULL;
    }
    ll->allocated = init_size;
    ll->entries = 0;
    return ll;
}

/* instr here is index into instruction list */
static
int label_list_insert(struct label_list_ **ll, struct instruction_ **instr) {
    if ((*ll)->entries - 1 == (*ll)->allocated) {
        size_t new_allocated = (*ll)->allocated + 256;
        void *tmp_ptr = realloc(*ll,  IL_SIZE(new_allocated));
        if (tmp_ptr == NULL) {
            fprintf(stderr, "%s():%s\n", "realloc", strerror(errno));
            return -1;
        }
        *ll = tmp_ptr;
        (*ll)->allocated = new_allocated;
    }

    DEBUG_NOTIFY("TRACE: adding label '%s'\n", (*instr)->label);

    (*ll)->label[(*ll)->entries].label = (*instr)->label;
    (*ll)->label[(*ll)->entries].instr = instr;
    (*ll)->entries += 1;
    return 0;
}

/* locate the index of a labelled instruction within the instruction list */
static
struct instruction_ **label_list_find_instr(struct label_list_ *ll, char *label) {
    size_t x;

    for (x = 0; x < ll->entries; x++) {
        if (strcmp(ll->label[x].label, label) == 0)
            return ll->label[x].instr;
    }
    return NULL;
}

/* look up the address of a calculated address */
static
int label_list_find_addr(struct label_list_ *ll, char *label, DCPU16_WORD *addr) {
    size_t x;

    for (x = 0; x < ll->entries; x++) {
        if (strcmp(ll->label[x].label, label) == 0) {
            if (ll->label[x].ready == 1) {
                *addr = ll->label[x].addr;
                return 0;
            }
        }
    }
    return -1;
}

/* attempt to determine the addresses of labels */
static
void label_addr_calculate_(struct instruction_list_ *il, struct label_list_ *ll) {
    size_t i;

    /* walk through labels */
    for (i = 0; i < ll->entries; i++) {
        struct instruction_ **instr;
        unsigned int word_count = 0;

        if (ll->label[i].ready)
            continue;

        /*
         *  walk backwards through the list of instructions
         *  until we get to the start or a known prior label address
         *  update our label
         */
        for (instr = ll->label[i].instr; instr >= il->instr; instr--) {

            word_count += (*instr)->length;

            if ((*instr)->label
            &&  strcmp((*instr)->label, ll->label[i].label)) {
                DCPU16_WORD addr;

                if (label_list_find_addr(ll, (*instr)->label, &addr)) {
                    fprintf(stderr, "internal error: incomplete prior address for '%s' while calculating '%s'\n",
                            (*instr)->label,
                            ll->label[i].label);
                    continue;
                }
                word_count += addr;
                break;
            }
        }
        ll->label[i].addr = word_count;
        ll->label[i].ready = 1;
        DEBUG_NOTIFY("label '%s' has addr of 0x%04x\n", ll->label[i].label, word_count);
    }
}

static
void instr_free_(struct instruction_ *i) {
    if (i->label)
        free(i->label);
    if (i->opcode)
        free(i->opcode);
    while (i->operands) {
        struct operand_ *o = i->operands;

        i->operands = o->next;
        free(o);
    }

    free(i);
}

/* generate the nibble for a given basic opcode */
static
int opcode_bits_(char *opcode) {
    static struct {
        char op[4];
        char value;
    } opcodes_lower_nibble[] = {
        { "JSR", 0x00 },
        /* { "future nbi instruction", 0x00 }, */
        { "SET", 0x01 },
        { "ADD", 0x02 },
        { "SUB", 0x03 },
        { "MUL", 0x04 },
        { "DIV", 0x05 },
        { "MOD", 0x06 },
        { "SHL", 0x07 },
        { "SHR", 0x08 },
        { "AND", 0x09 },
        { "BOR", 0x0a },
        { "XOR", 0x0b },
        { "IFE", 0x0c },
        { "IFN", 0x0d },
        { "IFG", 0x0e },
        { "IFB", 0x0f },
        {    "", 0x00 }
    }, *o;

    for (o = opcodes_lower_nibble; o->op[0]; o++) {
        if (strcasecmp(o->op, opcode) == 0)
            break;
    }

    if (o->op[0] == '\0') {
        fprintf(stderr, "unknown instruction '%s'\n", opcode);
        return -1;
    }

    return o->value;
}

/* generate the six bits for a given nbi opcode (aka first operand to opcode 0x00) */
static
int nbi_opcode_bits_(char *nbi_opcode) {
    static struct {
        char op[4];
        char value;
    } nbi_opcodes_bits[] = {
        { "   ", 0x00 }, /* reserved for future */
        { "JSR", 0x01 },
        { "", 0x00 }
    }, *o;

    for (o = nbi_opcodes_bits; o->op[0]; o++) {
        if (strcasecmp(o->op, nbi_opcode) == 0)
            break;
    }

    if (o->op[0] == '\0') {
        fprintf(stderr, "unknown nbi instruction '%s'\n", o->op);
        return -1;
    }

    return o->value;
}

/* convert register character like 'x' to value like 0x03 */
static inline
unsigned int register_enumerate_(char r) {
    const char regs[] = "AaBbCcXxYyZzIiJj";
    const char *x = strchr(regs, r);

    if (x)
        return (x - regs)/2;

    fprintf(stderr, "internal error, unknown register character 0x%02x\n", r);
    return -1;
}

/* generate the six bits for a given operand */
/* FIXME: MAEK BETTR */
/* notes: nextword may be rewritten even if it's not used in final instruction */
static
int value_bits_(struct label_list_ *ll, char *operand_orig, DCPU16_WORD *nextword, unsigned int *nextwordused, unsigned int allow_short_labels) {
    unsigned int retval = -1;
    unsigned long l;
    char *operand, *o, *ep;

    operand = o = strdup(operand_orig);

    DEBUG_NOTIFY("TRACE: operand '%s' is ", operand);

    if (strlen(operand) == 1) {
        if ( (strchr("ABCXYZIJ", *operand))
        ||   (strchr("abcxyzij", *operand)) ) {
            DEBUG_NOTIFY("register\n");
            retval = register_enumerate_(*operand);
            goto done;
        }
    }

    if (operand[0] == '[' && operand[strlen(operand) - 1] == ']') {
        operand[strlen(operand) - 1] = '\0';
        operand++;
        /* trim whitespaces */
        while (strchr(" \t\n", *operand)) operand++;
        ep = operand + strlen(operand) - 1;

        if (strlen(operand) == 1) {
            DEBUG_NOTIFY("dereferenced register\n");
            retval = 0x08 | register_enumerate_(*operand);
            goto done;
        }

        if ( (ep = strchr(operand, '+')) ) {
            char reg;
            char *constant;

            while (strchr("+ \t\n", *ep)) {
                *ep = '\0';
                ep++;
            }
            if (strlen(ep) == 1) {
                reg = *ep;
                constant = operand;
            } else if (strlen(operand) == 1) {
                reg = *operand;
                constant = ep;
            } else {
                fprintf(stderr, "couldn't parse operand\n");
                goto done;
            }

            if ( strchr("ABCXYZIJ", reg)
            ||   strchr("abcxyzij", reg) ) {
                l = strtoul(constant, &ep, 0);
            }

            DEBUG_NOTIFY("dereferenced register+constant\n");

            DEBUG_NOTIFY("\tregister_index:%u %c\n", reg, register_enumerate_(reg));
            DEBUG_NOTIFY("\tconstant:%lu\n", l);

            *nextword = l & 0xffff;
            *nextwordused += 1;
            retval = 0x10 | register_enumerate_(reg);
            goto done;
        }

        l = strtoul(operand, &ep, 0);
        DEBUG_NOTIFY("dereferenced literal value %lu...\n", l);
        *nextword = l & 0xffff;
        *nextwordused += 1;
        retval = 0x1e;
        goto done;
    }

    if (strcasecmp(operand, "POP") == 0) {
        DEBUG_NOTIFY("POP\n");
        retval = 0x18;
        goto done;
    }
    if (strcasecmp(operand, "PUSH") == 0) {
        DEBUG_NOTIFY("PUSH\n");
        retval = 0x19;
        goto done;
    }
    if (strcasecmp(operand, "PEEK") == 0) {
        DEBUG_NOTIFY("PEEK\n");
        retval = 0x1a;
        goto done;
    }
    if (strcasecmp(operand, "SP") == 0) {
        DEBUG_NOTIFY("sp register\n");
        retval = 0x1b;
        goto done;
    }
    if (strcasecmp(operand, "PC") == 0) {
        DEBUG_NOTIFY("pc register\n");
        retval = 0x1c;
        goto done;
    }
    if (strcasecmp(operand, "O") == 0) {
        DEBUG_NOTIFY("o register\n");
        retval = 0x1d;
        goto done;
    }

    l = strtoul(operand, &ep, 0);

    if (operand && *ep == '\0') {
        DEBUG_NOTIFY("literal value %lu...\n", l);
        if (l < 0x20) {
            retval = l + 0x20;
            goto done;
        } else {
            *nextword = l & 0xffff;
            *nextwordused += 1;
            retval = 0x1f;
            goto done;
        }
    }

    /* try to populate nextword with label address */
    if (label_list_find_addr(ll, operand, nextword)) {
        DEBUG_NOTIFY("currently-unknown label...\n");
        /* assume non-small literal value */
        *nextwordused += 1;
        goto done;
    }

    DEBUG_NOTIFY("label '%s' 0x%02hx\n", operand, *nextword);
    if (*nextword < 0x20 && allow_short_labels) {
        DEBUG_NOTIFY("small value label win\n");
        retval = (0x20 + *nextword) & 0x3f;
        goto done;
    }

    retval = 0x1f;
    *nextwordused += 1;

done:
    free(o);
    return retval;
}

static inline
int instruction_print_(struct instruction_ *i, unsigned int with_label) {
    struct operand_ *o;
    int r;

    if (with_label)
        r = printf("%-16s %3s", i->label ? i->label : "", i->opcode);
    else
        r = printf("%3s", i->opcode);

    for (o = i->operands; o; o = o->next)
        r += printf(" %s%s", o->operand, o->next ? "," : "");

    return r;
}

/* parse an instruction out of buf, create new instruction struct if seemingly valid */
/* does not actually check if instruction is valid yet */
/* buf must be 0-terminated */
static
int buf_tokenize_(char *buf, struct instruction_ **next_instr) {
    const char const *sep = " \t\n";
    struct instruction_ *instr = NULL;
    char *label = NULL,
         *opcode = NULL,
         *operand = NULL;

    char *x,
         *y,
         *st;

    assert(buf != NULL);
    assert(next_instr != NULL);

    *next_instr = NULL;

    /* kill comments */
    if ((x = strchr(buf, ';')) != NULL)
        *x = '\0';
    /* kill leading whitespace */
    buf += strspn(buf, " \t\n");
    /* kill trailing whitespace */
    if (*buf) {
        x = buf + strlen(buf);
        while (strchr(" \t\n", *x)) {
            *x = '\0';
            x--;
        }
    }

    if ((x = strrchr(buf, '\n')) != NULL)
        *x = '\0';

    /* determine if first token is label, opcode, or we just have a blank line to ignore */
    x = strtok_r(buf, sep, &st);

    /* empty line? nothing to do here. */
    if (x == NULL)
        return 0;

#ifdef OTHER_LABELS
    /* labels end with :, otherwise its an opcode */
    y = x + strlen(x) - 1;
    if (*y == ':') {
        *y = '\0';
        label = x;
        opcode = strtok_r(NULL, sep, &st);
    }
#else /* OTHER_LABELS */
    /* labels.. begin? with ':' ? okay, I guess. Whatever. */
    /* otherwise, it's an opcode */
    if (*x == ':') {
        label = x + 1;
        opcode = strtok_r(NULL, sep, &st);
    } else {
        label = NULL;
        opcode = x;
    }
#endif /* OTHER_LABELS */

    if (opcode) {
        operand = st;
    }

    /* extra room for assembled words */
    instr = calloc(1, 3 + sizeof *instr);
    if (instr == NULL) {
        fprintf(stderr, "%s():%s\n", "calloc", strerror(errno));
        return -1;
    }

    instr->label = label ? strdup(label) : NULL;
    instr->opcode = opcode ? strdup(opcode) : NULL;

    if (operand) {
        struct operand_ **o_next = &instr->operands;

        for (x = strtok_r(operand, ",", &st);
             x;
             x = strtok_r(NULL, ",", &st) ) {
            *o_next = malloc(3 + sizeof **o_next); /* FIXME: handle this on the fly later */

            if (*o_next == NULL) {
                fprintf(stderr, "%s():%s\n", "calloc", strerror(errno));
                instr_free_(instr);
                return -1;
            }

            /* trim */
            x += strspn(x, " \t\n");
            if (*x) {
                y = x + strlen(x) - 1;
                while (strchr(" \t\n", *y)) {
                    *y = '\0';
                    y--;
                }
            }

            (*o_next)->operand = strdup(x);
            (*o_next)->next = NULL;
            o_next = &((*o_next)->next);
        }
    }

    *next_instr = instr;

    return 0;
}

/* try to generate bytecode for an instruction */
static
void instr_bytecodify_(struct label_list_ *ll, struct instruction_ *i, unsigned int allow_short_labels) {
    unsigned int nwu = 0; /* number of words used */
    unsigned int incomplete = 0;
    int bits;
    struct operand_ *o = i->operands;

    DEBUG_NOTIFY("TRACE: codifying %s%s'%s'...", i->label ? i->label : "", i->label ? ":" : "", i->opcode);

    if (i->ready) {
        /* already codified */
        return;
    }

    /* special case DAT */
    if (strncasecmp(i->opcode, "DAT", 3) == 0) {
        /* just dump operands into words, I guess */
        fprintf(stderr, "FIXME unhandled raw data\n");
        /* count total length of data.. */
        /* realloc instruction */
        /* populate words */
        return;
    }

    /* start with opcode bits */
    bits = opcode_bits_(i->opcode);
    if (bits < 0) {
        fprintf(stderr, "unrecognized instruction '%s'\n", i->opcode);
        return;
    }
    i->instr_words[0] |= 0x0f & bits;

    /* in rendered bytecode, all instructions have two operands; nbi instructions take 'first operand' bits. */
    if ((bits & 0x0f) == 0) {
        bits = nbi_opcode_bits_(i->opcode);
        if (bits < 0) {
            fprintf(stderr, "internal error: missing instruction in nbi opcode table\n");
            return;
        }
    } else {
        if (o == NULL) {
            fprintf(stderr, "'%s' requires more operands\n", i->opcode);
            return;
        }
        bits = value_bits_(ll, o->operand, i->instr_words + 1, &nwu, allow_short_labels);
        if (bits < 0) {
            DEBUG_NOTIFY("TRACE: unresolved label\n");
            /* keep going, but don't finalize until we can calculate label address */
            incomplete = 1;
            bits = 0;
        }
        o = o->next;
    }
    i->instr_words[0] |= (bits & 0x3f) << 4;

    if (o == NULL) {
        fprintf(stderr, "'%s' requires more operands\n", i->opcode);
        return;
    }

    bits = value_bits_(ll, o->operand, i->instr_words + nwu + 1, &nwu, allow_short_labels);
    if (bits < 0) {
        DEBUG_NOTIFY("TRACE: unresolved label\n");
        /* keep going, but don't finalize until we can calculate label address */
        incomplete = 1;
        bits = 0;
    }
    o = o->next;
    i->instr_words[0] |= (bits & 0x3f) << 10;

    /* counting labels as words, we now know the maximum instruction length */
    /* if label is < 0x20, it can take up less space */

    i->length = nwu + 1;

    DEBUG_NOTIFY("instruction words: [%u]", i->length);
    for (bits = 0; bits <= (int)nwu; bits++)
        DEBUG_NOTIFY(" 0x%04x", i->instr_words[bits]);

    if (incomplete) {
        DEBUG_NOTIFY(" (preliminary)");
    } else {
        i->ready = 1;
    }

    DEBUG_NOTIFY("\n");
}

/* thish should grow buffer to fit huge linesh, but I jusht don't care right now, hic */
static
int parse_stream_(FILE *f, struct instruction_list_ **il, struct label_list_ **ll, unsigned int allow_short_labels) {
    struct instruction_ *instr, **instr_list_entry;
    char buf[(1<<14)];

    buf[sizeof buf - 1] = '\0';

    while (fgets(buf, sizeof buf, f)) {
        if (buf[sizeof buf - 1] != '\0') {
            fprintf(stderr, "input buffer exhausted\n");
            break;
        }

        if (buf_tokenize_(buf, &instr)) {
            fprintf(stderr, "trouble tokenizing input\n");
            break;
        }

        if (instr) {
            /* add to list of instructions */
            if (instr_list_insert(il, instr)) {
                fprintf(stderr, "could not populate instruction list\n");
            }
            instr_list_entry = (*il)->instr + (*il)->entries - 1;
            DEBUG_NOTIFY("TRACE: verify %s == %s\n", (*instr_list_entry)->opcode, instr->opcode);
            if (instr->label) {
                if (label_list_find_instr(*ll, instr->label)) {
                    fprintf(stderr, "duplicate label\n");
                    break;
                }
                if (label_list_insert(ll, instr_list_entry)) {
                    fprintf(stderr, "could not populate label list\n");
                }
                label_addr_calculate_(*il, *ll);
            }

            instr_bytecodify_(*ll, instr, allow_short_labels);
        }
    }
    if (ferror(f)) {
        fprintf(stderr, "%s():%s\n", "fgets", strerror(errno));
        return -1;
    }
    if (! feof(f)) {
        fprintf(stderr, "parsing aborted\n");
        return -1;
    }

    return 0;
}

static
int assemble_check_(struct instruction_list_ *il, struct label_list_ *ll, unsigned int allow_short_labels) {
    int retval = 0;
    size_t x;

    DEBUG_NOTIFY(" final pass of codifier...\n");
    for (x = 0; x < il->entries; x++) {
        instr_bytecodify_(ll, il->instr[x], allow_short_labels);
    }

    VERBOSE_NOTIFY("%3s %6s %-32s %-4s\n", "", "_addr_", "_label_", "_instruction_");
    for (x = 0; x < ll->entries; x++) {
        if (! ll->label[x].ready)
            retval |= -1;
        VERBOSE_NOTIFY("%3s0x%04x  %-32s ",
                       ll->label[x].ready ? "" : "*",
                       ll->label[x].addr,
                       ll->label[x].label);
        if (verbose_) {
            instruction_print_(*(ll->label[x].instr), 0);
            printf("\n");
        }
    }

    VERBOSE_NOTIFY("\n");

    if (retval)
        fprintf(stderr, "some labels could not be resolved\n");

    return retval;
}

static
int output_(struct instruction_list_ *il, const char *filename) {
    FILE *of = NULL;
    struct instruction_ *instr;
    size_t i, r, total_words = 0;
    size_t x;

    if (! dryrun_) {
        of = fopen(filename, "w");
        if (of == NULL) {
            fprintf(stderr, "%s('%s'):%s\n", "fopen", filename, strerror(errno));
            return -1;
        }
    }

    for (i = 0; i < il->entries; i++) {
        instr = il->instr[i];

        if (verbose_) {
            int s;
            s = instruction_print_(instr, 1);
            printf("%*s;", (44 - s) > 0 ? (44 - s) : 0, "");
            for (x = 0; x < instr->length; x++) {
                printf(" %04x", instr->instr_words[x]);
            }
            printf("\n");
        }

        if (of) {
            r = fwrite(instr->instr_words, sizeof(DCPU16_WORD), instr->length, of);
            if (r < instr->length) {
                fprintf(stderr, "%s():%s\n", "fwrite", strerror(errno));
                return -1;
            }
        }
        total_words += instr->length;
    }

    fprintf(stderr, "wrote 0x%04zx instructions as 0x%04zx words\n",
            i,
            total_words);
    return 0;
}

static struct instruction_list_ *il_;
static struct label_list_ *ll_;

int main(int argc, char *argv[]) {
    const char *out_filename = NULL;
    unsigned int allow_short_labels = 0;
    int c;

    while ( (c = getopt(argc, argv, "dhsvo:")) != EOF ) {
        switch (c) {
            case 'd':
                dryrun_++;
                break;

            case 's':
                allow_short_labels++;
                break;

            case 'o':
                if (out_filename) {
                    fprintf(stderr, "Sorry, I can only write one file at a time.\n");
                    exit(EX_CANTCREAT);
                }
                out_filename = optarg;
                break;

            case 'v':
                verbose_++;
                break;

            case 'h':
                usage_(argv[0], 1);
                exit(EX_OK);

            default:
                usage_(argv[0], 0);
                exit(EX_USAGE);
        }
    }

    argc -= optind;
    argv += optind;

    if (out_filename == NULL)
        out_filename = out_filename_default_;

    /* init tables */
    il_ = instr_list_new();
    ll_ = label_list_new();

    /* if filenames were specified, parse them instead of stdin */
    if (argc) {
        while (argc) {
            char *filename = *argv;
            FILE *f = fopen(filename, "r");

            argc--, argv++;

            if (f == NULL) {
                fprintf(stderr, "%s('%s'):%s\n", "fopen", filename, strerror(errno));
                continue;
            }

            VERBOSE_NOTIFY("assembling '%s'...\n", filename);
            parse_stream_(f, &il_, &ll_, allow_short_labels);

            fclose(f);
        }
    } else {
        VERBOSE_NOTIFY("assembling '%s'...\n", "stdin");
        parse_stream_(stdin, &il_, &ll_, allow_short_labels);
    }

    if (assemble_check_(il_, ll_, allow_short_labels)) {
        fprintf(stderr, "errors prevented assembly\n");
        exit(EX_DATAERR);
    }

    if (output_(il_, out_filename)) {
        fprintf(stderr, "failed to create output\n");
        exit(EX_OSERR);
    }

    exit(EX_OK);
}