kotnen's stats

# For any point P = (x, y):
#     P can be seen because its an empty plane with no obstructions.
can_see_point = lambda x: lambda y: x

// the extension time is almost gone, and i don't have anymore time to work on this (im going to a concert!)
// so i can't work on this anymore. so, i'm submitting an unfinished copy of this.
// i really am sorry about it being unfinished, but i don't have much of a choice here: it's either participate or don't,
// and i really do want to participate.

// P.S. compile with       g++ kimapr.c -fpermissive -lgmp
//      IF  :   you dont have obstack
//      THEN:   add obstack.c to the g++ command.


/* DONE:
    all of the trivial shit
*/

/* TODO:
    fix all of the FIXME list
    add randomi[zs]ation for probablistic-ization of PricK
*/

/* FIXME:
    conditionals are fucked
    like really really fucked
*/

/*
The author of this file IS NOT one of the following people:
 lyricly
 razetime
 r. "essaie" sa
 olive
 olus "olly" 2000
 olivia
 IFcoltransG
 sofia
 kotnen
 zptr yui
 mark
 palailogos
 at (DataKinds)

The author of this file IS one of the following people:
 GNU Radio Shows
 seshoumara

Impersonating people who aren't even playing is fun. Maybe next time i'll impersonate someone else.
*/



#if __has_include(<obstack.h>)
# include <obstack.h>
#else
# include "obstack.h"
#endif


static struct flags
{
    int helpinfo, versions;
    char*verb,*post,*p, sn;
} flgs;

#include <unordered_map>

#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
static int c, i, v, n;
void parseopt(int argc, char *const argv[])
{
    static const struct option lopts[] = {
        {"help",     no_argument,       &flgs.helpinfo, 1},
        {"version",  no_argument,       &flgs.versions, 1},
        {"before",   required_argument, 0,              'b'},
        {"after",    required_argument, 0,              'a'},
        {"command",  required_argument, 0,              'c'},
        {0,          0,                 0,              0},
    };
    while((c = getopt_long(argc, argv, "hHvVc:C:b:B:a:A:",
                           lopts, &i)) != -1){
        switch(c) {
        case '?':
            printf("use --help\n");
        case 0:
            break;
        case 'h': case 'H':
            flgs.helpinfo = 1;
            break;
        case 'v': case 'V':
            flgs.versions = 1;
            break;
        case 'c': case 'C':
            flgs.p=optarg;
            flgs.sn=1;
            break;
        case 'b': case 'B':
            flgs.verb=optarg;
            break;
        case 'a': case 'A':
            flgs.post=optarg;
            break;
        }
    }
    if (optind < argc){
        if (flgs.p||++optind<argc) {
            printf("%s: unexpected positional argument -- %s",
                   argv[0], argv[optind]);
            exit(-1);
        }
        flgs.p = argv[--optind];
    }
}



#include <string.h>
#include <stack>
char *E;
int exc(char*e){strcpy((E=realloc(E,(n+=(i=strlen(e)))+1))+n-i,e);}



#if __has_include(<gmp.h>)
# include <gmp.h>
#else
# error what the SIGMA?!you promised me gmplib!
#endif
int rnc();
static struct Ss{
    struct obstack ostcak{};
    std::stack<int> stcak{};
    std::unordered_map<int,int> arm{}; // sparse memory representation
} *stk;
#define MPZ_POP(n)\
if(cr.stcak.empty())mpz_init(n); \
else (mpz_init_set_ui(n,cr.stcak.top()),cr.stcak.pop());
#define MPZ_MEM(n, a)\
if(!cr.arm.count(mpz_get_ui(a)))mpz_init(n); \
else mpz_init_set_ui(n,cr.arm[mpz_get_ui(a)]);
#ifdef useobskcatk
#define OBJECTSTAKDFLK\
obstack_init(&cr.ostcak);obstack_free(&cr.ostcak, NULL);
#else
#define OBJECTSTAKDFLK
#endif
#define FALL \
for(c = 0; c < v; c++){struct Ss& cr = stk[c];OBJECTSTAKDFLK
int cond(){
    struct Ss& cr = stk[c];
    i++;
    int I=i;
    int J=i;
    int bal=1;
    for(;bal;J++){
        bal += E[J] == '[';
        bal -= E[J] == ']';
    };
    mpz_t b; MPZ_POP(b);
    while (1){
        while(E[i]!='|')
            rnc();
        mpz_t N; MPZ_POP(N);
        if (mpz_cmp_ui(N, 0) && mpz_cmp_ui(b, 0)){
            while(E[i]!=']')
                rnc();
        } else break;
        i=I;
    }
    i=J;
}
int rnc(){
    printf("%d %c\n", E[i], E[i]);
switch(E[i]){
case '#':
    FALL;cr.stcak.push(0);};
break;case '+':
    FALL;mpz_t t;MPZ_POP(t);mpz_add_ui(t, t, 1);
   cr.stcak.push(mpz_get_ui(t));mpz_clear(t);};
break;case '@':
    FALL;mpz_t s,m;MPZ_POP(s);MPZ_MEM(m,s);mpz_clear(s);
   cr.stcak.push(mpz_get_ui(m));mpz_clear(m);};break;
case '!':
    FALL;mpz_t a,V;MPZ_POP(a);MPZ_POP(V);
   cr.arm[mpz_get_ui(a)]=mpz_get_ui(V);
   mpz_clear(a);mpz_clear(V);};
break;case '[':cond();
break;case '|':case ']':i++;return;
break;case '?':
break;default:
    printf("bad syntax. %s",
           "see --help output for more information.\n");
exit(-1);
};i++;}
int cleanup() {for (; i < n-1 && E[i];)rnc();
FALL;printf("%d\n", cr.stcak.top());};
}

int main(int argc, char* argv[]) {
    parseopt(argc, argv); v++;
    if (flgs.helpinfo)
        printf("lol no, just read the source code\n"), exit(-1);
    if (flgs.versions)
        printf("%s v6.9\n", argv[0]),                  exit(-1);
    stk = (struct Ss *)calloc(v, sizeof(struct Ss));
    stk[0] = Ss{};
    E = (char *)malloc(n=0);
    if (flgs.verb) exc(flgs.verb);
    if (flgs.sn)   exc(flgs.p);
    else {
        FILE* f = flgs.p ? fopen(flgs.p, "r") : stdin;
        while ((c = getc(f)) != EOF) exc((char *)&c);
    }
    if (flgs.post) exc(flgs.post);
    i=0;cleanup();
}

/* obstack.c - subroutines used implicitly by object stack macros
   Copyright (C) 1988-2024 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   This file is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as
   published by the Free Software Foundation, either version 3 of the
   License, or (at your option) any later version.

   This file is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */


#ifdef _LIBC
# include <obstack.h>
#else
//# include <config.h>
# include "obstack.h"
#endif

/* NOTE BEFORE MODIFYING THIS FILE IN GNU LIBC: _OBSTACK_INTERFACE_VERSION in
   gnu-versions.h must be incremented whenever callers compiled using an old
   obstack.h can no longer properly call the functions in this file.  */

/* If GCC, or if an oddball (testing?) host that #defines __alignof__,
   use the already-supplied __alignof__.  Otherwise, this must be Gnulib
   (as glibc assumes GCC); defer to Gnulib's alignof_type.  */
#if !defined __GNUC__ && !defined __alignof__
# include <alignof.h>
# define __alignof__(type) alignof_type (type)
#endif
#include <stdlib.h>
#include <stdint.h>

#ifndef MAX
# define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif

/* Determine default alignment.  */

/* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT.
   But in fact it might be less smart and round addresses to as much as
   DEFAULT_ROUNDING.  So we prepare for it to do that.

   DEFAULT_ALIGNMENT cannot be an enum constant; see gnulib's alignof.h.  */
#define DEFAULT_ALIGNMENT MAX (__alignof__ (long double),		      \
                               MAX (__alignof__ (uintmax_t),		      \
                                    __alignof__ (void *)))
#define DEFAULT_ROUNDING MAX (sizeof (long double),			      \
                               MAX (sizeof (uintmax_t),			      \
                                    sizeof (void *)))

/* Call functions with either the traditional malloc/free calling
   interface, or the mmalloc/mfree interface (that adds an extra first
   argument), based on the value of use_extra_arg.  */

static void *
call_chunkfun (struct obstack *h, size_t size)
{
  if (h->use_extra_arg)
    return h->chunkfun.extra (h->extra_arg, size);
  else
    return h->chunkfun.plain (size);
}

static void
call_freefun (struct obstack *h, void *old_chunk)
{
  if (h->use_extra_arg)
    h->freefun.extra (h->extra_arg, old_chunk);
  else
    h->freefun.plain (old_chunk);
}


/* Initialize an obstack H for use.  Specify chunk size SIZE (0 means default).
   Objects start on multiples of ALIGNMENT (0 means use default).

   Return nonzero if successful, calls obstack_alloc_failed_handler if
   allocation fails.  */

static int
_obstack_begin_worker (struct obstack *h,
                       _OBSTACK_SIZE_T size, _OBSTACK_SIZE_T alignment)
{
  struct _obstack_chunk *chunk; /* points to new chunk */

  if (alignment == 0)
    alignment = DEFAULT_ALIGNMENT;
  if (size == 0)
    /* Default size is what GNU malloc can fit in a 4096-byte block.  */
    {
      /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc.
         Use the values for range checking, because if range checking is off,
         the extra bytes won't be missed terribly, but if range checking is on
         and we used a larger request, a whole extra 4096 bytes would be
         allocated.

         These number are irrelevant to the new GNU malloc.  I suspect it is
         less sensitive to the size of the request.  */
      int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1))
                    + 4 + DEFAULT_ROUNDING - 1)
                   & ~(DEFAULT_ROUNDING - 1));
      size = 4096 - extra;
    }

  h->chunk_size = size;
  h->alignment_mask = alignment - 1;

  chunk = h->chunk = call_chunkfun (h, h->chunk_size);
  if (!chunk)
    (*obstack_alloc_failed_handler) ();
  h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents,
                                               alignment - 1);
  h->chunk_limit = chunk->limit = (char *) chunk + h->chunk_size;
  chunk->prev = 0;
  /* The initial chunk now contains no empty object.  */
  h->maybe_empty_object = 0;
  h->alloc_failed = 0;
  return 1;
}

int
_obstack_begin (struct obstack *h,
                _OBSTACK_SIZE_T size, _OBSTACK_SIZE_T alignment,
                void *(*chunkfun) (size_t),
                void (*freefun) (void *))
{
  h->chunkfun.plain = chunkfun;
  h->freefun.plain = freefun;
  h->use_extra_arg = 0;
  return _obstack_begin_worker (h, size, alignment);
}

int
_obstack_begin_1 (struct obstack *h,
                  _OBSTACK_SIZE_T size, _OBSTACK_SIZE_T alignment,
                  void *(*chunkfun) (void *, size_t),
                  void (*freefun) (void *, void *),
                  void *arg)
{
  h->chunkfun.extra = chunkfun;
  h->freefun.extra = freefun;
  h->extra_arg = arg;
  h->use_extra_arg = 1;
  return _obstack_begin_worker (h, size, alignment);
}

/* Allocate a new current chunk for the obstack *H
   on the assumption that LENGTH bytes need to be added
   to the current object, or a new object of length LENGTH allocated.
   Copies any partial object from the end of the old chunk
   to the beginning of the new one.  */

void
_obstack_newchunk (struct obstack *h, _OBSTACK_SIZE_T length)
{
  struct _obstack_chunk *old_chunk = h->chunk;
  struct _obstack_chunk *new_chunk = 0;
  size_t obj_size = h->next_free - h->object_base;
  char *object_base;

  /* Compute size for new chunk.  */
  size_t sum1 = obj_size + length;
  size_t sum2 = sum1 + h->alignment_mask;
  size_t new_size = sum2 + (obj_size >> 3) + 100;
  if (new_size < sum2)
    new_size = sum2;
  if (new_size < h->chunk_size)
    new_size = h->chunk_size;

  /* Allocate and initialize the new chunk.  */
  if (obj_size <= sum1 && sum1 <= sum2)
    new_chunk = call_chunkfun (h, new_size);
  if (!new_chunk)
    (*obstack_alloc_failed_handler)();
  h->chunk = new_chunk;
  new_chunk->prev = old_chunk;
  new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size;

  /* Compute an aligned object_base in the new chunk */
  object_base =
    __PTR_ALIGN ((char *) new_chunk, new_chunk->contents, h->alignment_mask);

  /* Move the existing object to the new chunk.  */
  memcpy (object_base, h->object_base, obj_size);

  /* If the object just copied was the only data in OLD_CHUNK,
     free that chunk and remove it from the chain.
     But not if that chunk might contain an empty object.  */
  if (!h->maybe_empty_object
      && (h->object_base
          == __PTR_ALIGN ((char *) old_chunk, old_chunk->contents,
                          h->alignment_mask)))
    {
      new_chunk->prev = old_chunk->prev;
      call_freefun (h, old_chunk);
    }

  h->object_base = object_base;
  h->next_free = h->object_base + obj_size;
  /* The new chunk certainly contains no empty object yet.  */
  h->maybe_empty_object = 0;
}

/* Return nonzero if object OBJ has been allocated from obstack H.
   This is here for debugging.
   If you use it in a program, you are probably losing.  */

/* Suppress -Wmissing-prototypes warning.  We don't want to declare this in
   obstack.h because it is just for debugging.  */
int _obstack_allocated_p (struct obstack *h, void *obj) __attribute_pure__;

int
_obstack_allocated_p (struct obstack *h, void *obj)
{
  struct _obstack_chunk *lp;    /* below addr of any objects in this chunk */
  struct _obstack_chunk *plp;   /* point to previous chunk if any */

  lp = (h)->chunk;
  /* We use >= rather than > since the object cannot be exactly at
     the beginning of the chunk but might be an empty object exactly
     at the end of an adjacent chunk.  */
  while (lp != 0 && ((void *) lp >= obj || (void *) (lp)->limit < obj))
    {
      plp = lp->prev;
      lp = plp;
    }
  return lp != 0;
}

/* Free objects in obstack H, including OBJ and everything allocate
   more recently than OBJ.  If OBJ is zero, free everything in H.  */

void
_obstack_free (struct obstack *h, void *obj)
{
  struct _obstack_chunk *lp;    /* below addr of any objects in this chunk */
  struct _obstack_chunk *plp;   /* point to previous chunk if any */

  lp = h->chunk;
  /* We use >= because there cannot be an object at the beginning of a chunk.
     But there can be an empty object at that address
     at the end of another chunk.  */
  while (lp != 0 && ((void *) lp >= obj || (void *) (lp)->limit < obj))
    {
      plp = lp->prev;
      call_freefun (h, lp);
      lp = plp;
      /* If we switch chunks, we can't tell whether the new current
         chunk contains an empty object, so assume that it may.  */
      h->maybe_empty_object = 1;
    }
  if (lp)
    {
      h->object_base = h->next_free = (char *) (obj);
      h->chunk_limit = lp->limit;
      h->chunk = lp;
    }
  else if (obj != 0)
    /* obj is not in any of the chunks! */
    abort ();
}

_OBSTACK_SIZE_T
_obstack_memory_used (struct obstack *h)
{
  struct _obstack_chunk *lp;
  _OBSTACK_SIZE_T nbytes = 0;

  for (lp = h->chunk; lp != 0; lp = lp->prev)
    {
      nbytes += lp->limit - (char *) lp;
    }
  return nbytes;
}

#ifndef _OBSTACK_NO_ERROR_HANDLER
/* Define the error handler.  */
# include <stdio.h>

/* Exit value used when 'print_and_abort' is used.  */
int obstack_exit_failure = EXIT_FAILURE;


static __attribute_noreturn__ void
print_and_abort (void)
{
  /* Don't change any of these strings.  Yes, it would be possible to add
     the newline to the string and use fputs or so.  But this must not
     happen because the "memory exhausted" message appears in other places
     like this and the translation should be reused instead of creating
     a very similar string which requires a separate translation.  */
  fprintf (stderr, "%s\n", "memory exhausted");
  exit (obstack_exit_failure);
}

/* The functions allocating more room by calling 'obstack_chunk_alloc'
   jump to the handler pointed to by 'obstack_alloc_failed_handler'.
   This can be set to a user defined function which should either
   abort gracefully or use longjump - but shouldn't return.  This
   variable by default points to the internal function
   'print_and_abort'.  */
__attribute_noreturn__ void (*obstack_alloc_failed_handler) (void)
  = print_and_abort;
#endif /* !_OBSTACK_NO_ERROR_HANDLER */

/* obstack.h - object stack macros
   Copyright (C) 1988-2024 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   This file is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as
   published by the Free Software Foundation, either version 3 of the
   License, or (at your option) any later version.

   This file is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

/* Summary:

   All the apparent functions defined here are macros. The idea
   is that you would use these pre-tested macros to solve a
   very specific set of problems, and they would run fast.
   Caution: no side-effects in arguments please!! They may be
   evaluated MANY times!!

   These macros operate a stack of objects.  Each object starts life
   small, and may grow to maturity.  (Consider building a word syllable
   by syllable.)  An object can move while it is growing.  Once it has
   been "finished" it never changes address again.  So the "top of the
   stack" is typically an immature growing object, while the rest of the
   stack is of mature, fixed size and fixed address objects.

   These routines grab large chunks of memory, using a function you
   supply, called 'obstack_chunk_alloc'.  On occasion, they free chunks,
   by calling 'obstack_chunk_free'.  You must define them and declare
   them before using any obstack macros.

   Each independent stack is represented by a 'struct obstack'.
   Each of the obstack macros expects a pointer to such a structure
   as the first argument.

   One motivation for this package is the problem of growing char strings
   in symbol tables.  Unless you are "fascist pig with a read-only mind"
   --Gosper's immortal quote from HAKMEM item 154, out of context--you
   would not like to put any arbitrary upper limit on the length of your
   symbols.

   In practice this often means you will build many short symbols and a
   few long symbols.  At the time you are reading a symbol you don't know
   how long it is.  One traditional method is to read a symbol into a
   buffer, realloc()ating the buffer every time you try to read a symbol
   that is longer than the buffer.  This is beaut, but you still will
   want to copy the symbol from the buffer to a more permanent
   symbol-table entry say about half the time.

   With obstacks, you can work differently.  Use one obstack for all symbol
   names.  As you read a symbol, grow the name in the obstack gradually.
   When the name is complete, finalize it.  Then, if the symbol exists already,
   free the newly read name.

   The way we do this is to take a large chunk, allocating memory from
   low addresses.  When you want to build a symbol in the chunk you just
   add chars above the current "high water mark" in the chunk.  When you
   have finished adding chars, because you got to the end of the symbol,
   you know how long the chars are, and you can create a new object.
   Mostly the chars will not burst over the highest address of the chunk,
   because you would typically expect a chunk to be (say) 100 times as
   long as an average object.

   In case that isn't clear, when we have enough chars to make up
   the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed)
   so we just point to it where it lies.  No moving of chars is
   needed and this is the second win: potentially long strings need
   never be explicitly shuffled. Once an object is formed, it does not
   change its address during its lifetime.

   When the chars burst over a chunk boundary, we allocate a larger
   chunk, and then copy the partly formed object from the end of the old
   chunk to the beginning of the new larger chunk.  We then carry on
   accreting characters to the end of the object as we normally would.

   A special macro is provided to add a single char at a time to a
   growing object.  This allows the use of register variables, which
   break the ordinary 'growth' macro.

   Summary:
        We allocate large chunks.
        We carve out one object at a time from the current chunk.
        Once carved, an object never moves.
        We are free to append data of any size to the currently
          growing object.
        Exactly one object is growing in an obstack at any one time.
        You can run one obstack per control block.
        You may have as many control blocks as you dare.
        Because of the way we do it, you can "unwind" an obstack
          back to a previous state. (You may remove objects much
          as you would with a stack.)
 */

/* Documentation (part of the GNU libc manual):
   <https://www.gnu.org/software/libc/manual/html_node/Obstacks.html>  */


/* Don't do the contents of this file more than once.  */
#ifndef _OBSTACK_H
#define _OBSTACK_H 1

#include <stddef.h>             /* For size_t and ptrdiff_t.  */
#include <stdint.h>             /* For uintptr_t.  */
#include <string.h>             /* For memcpy.  */

#if __STDC_VERSION__ < 199901L || defined __HP_cc
# define __FLEXIBLE_ARRAY_MEMBER 1
#else
# define __FLEXIBLE_ARRAY_MEMBER
#endif

/* These macros highlight the places where this implementation
   is different from the one in GNU libc.  */
#ifdef _LIBC
# define _OBSTACK_SIZE_T unsigned int
# define _CHUNK_SIZE_T unsigned long
# define _OBSTACK_CAST(type, expr) ((type) (expr))
#else
/* In Gnulib, we use sane types, especially for 64-bit hosts.  */
# define _OBSTACK_SIZE_T size_t
# define _CHUNK_SIZE_T size_t
# define _OBSTACK_CAST(type, expr) (expr)
#endif

/* __PTR_ALIGN(B, P, A) returns the result of aligning P to the next multiple
   of A + 1.  B must be the base of an object addressed by P.  B and P must be
   of type char *.  A + 1 must be a power of 2.
   If ptrdiff_t is narrower than a pointer (e.g., the AS/400), play it
   safe and compute the alignment relative to B.  Otherwise, use the
   faster strategy of computing the alignment through uintptr_t.  */
#define __PTR_ALIGN(B, P, A) \
   ((P) + ((- (uintptr_t) (P)) & (A)))

#ifndef __attribute_pure__
# define __attribute_pure__ _GL_ATTRIBUTE_PURE
#endif

/* Not the same as _Noreturn, since it also works with function pointers.  */
#ifndef __attribute_noreturn__
# if 2 < __GNUC__ + (8 <= __GNUC_MINOR__) || defined __clang__ || 0x5110 <= __SUNPRO_C
#  define __attribute_noreturn__ __attribute__ ((__noreturn__))
# else
#  define __attribute_noreturn__
# endif
#endif

#ifdef __cplusplus
extern "C" {
#endif

struct _obstack_chunk           /* Lives at front of each chunk. */
{
  char *limit;                  /* 1 past end of this chunk */
  struct _obstack_chunk *prev;  /* address of prior chunk or NULL */
  char contents[__FLEXIBLE_ARRAY_MEMBER]; /* objects begin here */
};

struct obstack          /* control current object in current chunk */
{
  _CHUNK_SIZE_T chunk_size;     /* preferred size to allocate chunks in */
  struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */
  char *object_base;            /* address of object we are building */
  char *next_free;              /* where to add next char to current object */
  char *chunk_limit;            /* address of char after current chunk */
  union
  {
    _OBSTACK_SIZE_T i;
    void *p;
  } temp;                       /* Temporary for some macros.  */
  _OBSTACK_SIZE_T alignment_mask;  /* Mask of alignment for each object. */

  /* These prototypes vary based on 'use_extra_arg'.  */
  union
  {
    void *(*plain) (size_t);
    void *(*extra) (void *, size_t);
  } chunkfun;
  union
  {
    void (*plain) (void *);
    void (*extra) (void *, void *);
  } freefun;

  void *extra_arg;              /* first arg for chunk alloc/dealloc funcs */
  unsigned use_extra_arg : 1;     /* chunk alloc/dealloc funcs take extra arg */
  unsigned maybe_empty_object : 1; /* There is a possibility that the current
                                      chunk contains a zero-length object.  This
                                      prevents freeing the chunk if we allocate
                                      a bigger chunk to replace it. */
  unsigned alloc_failed : 1;      /* No longer used, as we now call the failed
                                     handler on error, but retained for binary
                                     compatibility.  */
};

/* Declare the external functions we use; they are in obstack.c.  */

extern void _obstack_newchunk (struct obstack *, _OBSTACK_SIZE_T);
extern void _obstack_free (struct obstack *, void *);
extern int _obstack_begin (struct obstack *,
                           _OBSTACK_SIZE_T, _OBSTACK_SIZE_T,
                           void *(*) (size_t), void (*) (void *));
extern int _obstack_begin_1 (struct obstack *,
                             _OBSTACK_SIZE_T, _OBSTACK_SIZE_T,
                             void *(*) (void *, size_t),
                             void (*) (void *, void *), void *);
extern _OBSTACK_SIZE_T _obstack_memory_used (struct obstack *)
  __attribute_pure__;


/* Error handler called when 'obstack_chunk_alloc' failed to allocate
   more memory.  This can be set to a user defined function which
   should either abort gracefully or use longjump - but shouldn't
   return.  The default action is to print a message and abort.  */
extern __attribute_noreturn__ void (*obstack_alloc_failed_handler) (void);

/* Exit value used when 'print_and_abort' is used.  */
extern int obstack_exit_failure;

/* Pointer to beginning of object being allocated or to be allocated next.
   Note that this might not be the final address of the object
   because a new chunk might be needed to hold the final size.  */

#define obstack_base(h) ((void *) (h)->object_base)

/* Size for allocating ordinary chunks.  */

#define obstack_chunk_size(h) ((h)->chunk_size)

/* Pointer to next byte not yet allocated in current chunk.  */

#define obstack_next_free(h) ((void *) (h)->next_free)

/* Mask specifying low bits that should be clear in address of an object.  */

#define obstack_alignment_mask(h) ((h)->alignment_mask)

/* To prevent prototype warnings provide complete argument list.  */
#define obstack_init(h)							      \
  _obstack_begin ((h), 0, 0,						      \
                  _OBSTACK_CAST (void *(*) (size_t), obstack_chunk_alloc),    \
                  _OBSTACK_CAST (void (*) (void *), obstack_chunk_free))

#define obstack_begin(h, size)						      \
  _obstack_begin ((h), (size), 0,					      \
                  _OBSTACK_CAST (void *(*) (size_t), obstack_chunk_alloc), \
                  _OBSTACK_CAST (void (*) (void *), obstack_chunk_free))

#define obstack_specify_allocation(h, size, alignment, chunkfun, freefun)     \
  _obstack_begin ((h), (size), (alignment),				      \
                  _OBSTACK_CAST (void *(*) (size_t), chunkfun),		      \
                  _OBSTACK_CAST (void (*) (void *), freefun))

#define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \
  _obstack_begin_1 ((h), (size), (alignment),				      \
                    _OBSTACK_CAST (void *(*) (void *, size_t), chunkfun),     \
                    _OBSTACK_CAST (void (*) (void *, void *), freefun), arg)

#define obstack_chunkfun(h, newchunkfun)				      \
  ((void) ((h)->chunkfun.extra = (void *(*) (void *, size_t)) (newchunkfun)))

#define obstack_freefun(h, newfreefun)					      \
  ((void) ((h)->freefun.extra = (void *(*) (void *, void *)) (newfreefun)))

#define obstack_1grow_fast(h, achar) ((void) (*((h)->next_free)++ = (achar)))

#define obstack_blank_fast(h, n) ((void) ((h)->next_free += (n)))

#define obstack_memory_used(h) _obstack_memory_used (h)

#if defined __GNUC__ || defined __clang__
# if !(defined __GNUC_MINOR__ && __GNUC__ * 1000 + __GNUC_MINOR__ >= 2008 \
       || defined __clang__)
#  define __extension__
# endif

/* For GNU C, if not -traditional,
   we can define these macros to compute all args only once
   without using a global variable.
   Also, we can avoid using the 'temp' slot, to make faster code.  */

# define obstack_object_size(OBSTACK)					      \
  __extension__								      \
    ({ struct obstack const *__o = (OBSTACK);				      \
       (_OBSTACK_SIZE_T) (__o->next_free - __o->object_base); })

/* The local variable is named __o1 to avoid a shadowed variable
   warning when invoked from other obstack macros.  */
# define obstack_room(OBSTACK)						      \
  __extension__								      \
    ({ struct obstack const *__o1 = (OBSTACK);				      \
       (_OBSTACK_SIZE_T) (__o1->chunk_limit - __o1->next_free); })

# define obstack_make_room(OBSTACK, length)				      \
  __extension__								      \
    ({ struct obstack *__o = (OBSTACK);					      \
       _OBSTACK_SIZE_T __len = (length);				      \
       if (obstack_room (__o) < __len)					      \
         _obstack_newchunk (__o, __len);				      \
       (void) 0; })

# define obstack_empty_p(OBSTACK)					      \
  __extension__								      \
    ({ struct obstack const *__o = (OBSTACK);				      \
       (__o->chunk->prev == 0						      \
        && __o->next_free == __PTR_ALIGN ((char *) __o->chunk,		      \
                                          __o->chunk->contents,		      \
                                          __o->alignment_mask)); })

# define obstack_grow(OBSTACK, where, length)				      \
  __extension__								      \
    ({ struct obstack *__o = (OBSTACK);					      \
       _OBSTACK_SIZE_T __len = (length);				      \
       if (obstack_room (__o) < __len)					      \
         _obstack_newchunk (__o, __len);				      \
       memcpy (__o->next_free, where, __len);				      \
       __o->next_free += __len;						      \
       (void) 0; })

# define obstack_grow0(OBSTACK, where, length)				      \
  __extension__								      \
    ({ struct obstack *__o = (OBSTACK);					      \
       _OBSTACK_SIZE_T __len = (length);				      \
       if (obstack_room (__o) < __len + 1)				      \
         _obstack_newchunk (__o, __len + 1);				      \
       memcpy (__o->next_free, where, __len);				      \
       __o->next_free += __len;						      \
       *(__o->next_free)++ = 0;						      \
       (void) 0; })

# define obstack_1grow(OBSTACK, datum)					      \
  __extension__								      \
    ({ struct obstack *__o = (OBSTACK);					      \
       if (obstack_room (__o) < 1)					      \
         _obstack_newchunk (__o, 1);					      \
       obstack_1grow_fast (__o, datum); })

/* These assume that the obstack alignment is good enough for pointers
   or ints, and that the data added so far to the current object
   shares that much alignment.  */

# define obstack_ptr_grow(OBSTACK, datum)				      \
  __extension__								      \
    ({ struct obstack *__o = (OBSTACK);					      \
       if (obstack_room (__o) < sizeof (void *))			      \
         _obstack_newchunk (__o, sizeof (void *));			      \
       obstack_ptr_grow_fast (__o, datum); })

# define obstack_int_grow(OBSTACK, datum)				      \
  __extension__								      \
    ({ struct obstack *__o = (OBSTACK);					      \
       if (obstack_room (__o) < sizeof (int))				      \
         _obstack_newchunk (__o, sizeof (int));				      \
       obstack_int_grow_fast (__o, datum); })

# define obstack_ptr_grow_fast(OBSTACK, aptr)				      \
  __extension__								      \
    ({ struct obstack *__o1 = (OBSTACK);				      \
       void *__p1 = __o1->next_free;					      \
       *(const void **) __p1 = (aptr);					      \
       __o1->next_free += sizeof (const void *);			      \
       (void) 0; })

# define obstack_int_grow_fast(OBSTACK, aint)				      \
  __extension__								      \
    ({ struct obstack *__o1 = (OBSTACK);				      \
       void *__p1 = __o1->next_free;					      \
       *(int *) __p1 = (aint);						      \
       __o1->next_free += sizeof (int);					      \
       (void) 0; })

# define obstack_blank(OBSTACK, length)					      \
  __extension__								      \
    ({ struct obstack *__o = (OBSTACK);					      \
       _OBSTACK_SIZE_T __len = (length);				      \
       if (obstack_room (__o) < __len)					      \
         _obstack_newchunk (__o, __len);				      \
       obstack_blank_fast (__o, __len); })

# define obstack_alloc(OBSTACK, length)					      \
  __extension__								      \
    ({ struct obstack *__h = (OBSTACK);					      \
       obstack_blank (__h, (length));					      \
       obstack_finish (__h); })

# define obstack_copy(OBSTACK, where, length)				      \
  __extension__								      \
    ({ struct obstack *__h = (OBSTACK);					      \
       obstack_grow (__h, (where), (length));				      \
       obstack_finish (__h); })

# define obstack_copy0(OBSTACK, where, length)				      \
  __extension__								      \
    ({ struct obstack *__h = (OBSTACK);					      \
       obstack_grow0 (__h, (where), (length));				      \
       obstack_finish (__h); })

/* The local variable is named __o1 to avoid a shadowed variable
   warning when invoked from other obstack macros, typically obstack_free.  */
# define obstack_finish(OBSTACK)					      \
  __extension__								      \
    ({ struct obstack *__o1 = (OBSTACK);				      \
       void *__value = (void *) __o1->object_base;			      \
       if (__o1->next_free == __value)					      \
         __o1->maybe_empty_object = 1;					      \
       __o1->next_free							      \
         = __PTR_ALIGN (__o1->object_base, __o1->next_free,		      \
                        __o1->alignment_mask);				      \
       if ((size_t) (__o1->next_free - (char *) __o1->chunk)		      \
           > (size_t) (__o1->chunk_limit - (char *) __o1->chunk))	      \
         __o1->next_free = __o1->chunk_limit;				      \
       __o1->object_base = __o1->next_free;				      \
       __value; })

# define obstack_free(OBSTACK, OBJ)					      \
  __extension__								      \
    ({ struct obstack *__o = (OBSTACK);					      \
       void *__obj = (void *) (OBJ);					      \
       if (__obj > (void *) __o->chunk && __obj < (void *) __o->chunk_limit)  \
         __o->next_free = __o->object_base = (char *) __obj;		      \
       else								      \
         _obstack_free (__o, __obj); })

#else /* not __GNUC__ */

# define obstack_object_size(h)						      \
  ((_OBSTACK_SIZE_T) ((h)->next_free - (h)->object_base))

# define obstack_room(h)						      \
  ((_OBSTACK_SIZE_T) ((h)->chunk_limit - (h)->next_free))

# define obstack_empty_p(h)						      \
  ((h)->chunk->prev == 0						      \
   && (h)->next_free == __PTR_ALIGN ((char *) (h)->chunk,		      \
                                     (h)->chunk->contents,		      \
                                     (h)->alignment_mask))

/* Note that the call to _obstack_newchunk is enclosed in (..., 0)
   so that we can avoid having void expressions
   in the arms of the conditional expression.
   Casting the third operand to void was tried before,
   but some compilers won't accept it.  */

# define obstack_make_room(h, length)					      \
  ((h)->temp.i = (length),						      \
   ((obstack_room (h) < (h)->temp.i)					      \
    ? (_obstack_newchunk (h, (h)->temp.i), 0) : 0),			      \
   (void) 0)

# define obstack_grow(h, where, length)					      \
  ((h)->temp.i = (length),						      \
   ((obstack_room (h) < (h)->temp.i)					      \
   ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0),			      \
   memcpy ((h)->next_free, where, (h)->temp.i),				      \
   (h)->next_free += (h)->temp.i,					      \
   (void) 0)

# define obstack_grow0(h, where, length)				      \
  ((h)->temp.i = (length),						      \
   ((obstack_room (h) < (h)->temp.i + 1)				      \
   ? (_obstack_newchunk ((h), (h)->temp.i + 1), 0) : 0),		      \
   memcpy ((h)->next_free, where, (h)->temp.i),				      \
   (h)->next_free += (h)->temp.i,					      \
   *((h)->next_free)++ = 0,						      \
   (void) 0)

# define obstack_1grow(h, datum)					      \
  (((obstack_room (h) < 1)						      \
    ? (_obstack_newchunk ((h), 1), 0) : 0),				      \
   obstack_1grow_fast (h, datum))

# define obstack_ptr_grow(h, datum)					      \
  (((obstack_room (h) < sizeof (char *))				      \
    ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0),		      \
   obstack_ptr_grow_fast (h, datum))

# define obstack_int_grow(h, datum)					      \
  (((obstack_room (h) < sizeof (int))					      \
    ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0),			      \
   obstack_int_grow_fast (h, datum))

# define obstack_ptr_grow_fast(h, aptr)					      \
  (((const void **) ((h)->next_free += sizeof (void *)))[-1] = (aptr),	      \
   (void) 0)

# define obstack_int_grow_fast(h, aint)					      \
  (((int *) ((h)->next_free += sizeof (int)))[-1] = (aint),		      \
   (void) 0)

# define obstack_blank(h, length)					      \
  ((h)->temp.i = (length),						      \
   ((obstack_room (h) < (h)->temp.i)					      \
   ? (_obstack_newchunk ((h), (h)->temp.i), 0) : 0),			      \
   obstack_blank_fast (h, (h)->temp.i))

# define obstack_alloc(h, length)					      \
  (obstack_blank ((h), (length)), obstack_finish ((h)))

# define obstack_copy(h, where, length)					      \
  (obstack_grow ((h), (where), (length)), obstack_finish ((h)))

# define obstack_copy0(h, where, length)				      \
  (obstack_grow0 ((h), (where), (length)), obstack_finish ((h)))

# define obstack_finish(h)						      \
  (((h)->next_free == (h)->object_base					      \
    ? (((h)->maybe_empty_object = 1), 0)				      \
    : 0),								      \
   (h)->temp.p = (h)->object_base,					      \
   (h)->next_free							      \
     = __PTR_ALIGN ((h)->object_base, (h)->next_free,			      \
                    (h)->alignment_mask),				      \
   (((size_t) ((h)->next_free - (char *) (h)->chunk)			      \
     > (size_t) ((h)->chunk_limit - (char *) (h)->chunk))		      \
   ? ((h)->next_free = (h)->chunk_limit) : 0),				      \
   (h)->object_base = (h)->next_free,					      \
   (h)->temp.p)

# define obstack_free(h, obj)						      \
  ((h)->temp.p = (void *) (obj),					      \
   (((h)->temp.p > (void *) (h)->chunk					      \
     && (h)->temp.p < (void *) (h)->chunk_limit)			      \
    ? (void) ((h)->next_free = (h)->object_base = (char *) (h)->temp.p)       \
    : _obstack_free ((h), (h)->temp.p)))

#endif /* not __GNUC__ */

#ifdef __cplusplus
}       /* C++ */
#endif

#endif /* _OBSTACK_H */

#! /bin/bash

# copyright (C)  Ly(r)icLy  2024

# this month's edition of   taswelll impersonation   is funded
# by viewers like you

# as always,   taswelll impersonation   is brought to you by:
# the Ly(r)icLy LLC. Co. MK. AB conglomorate company, Inc.  (all rights restricted)


# no waranty is provided; there is no guarantee of fitness for any purpose.
#     ^^^  im not capitalizing all that shit like normal licenses do



nl=$'\n'
tab=$'\t'

ddefault_flock_sl=0.05

#comment these out if your machine has a builtin flock and flunlock!!
flock(){
    if [ ${doverride_flock_sl} ]; then
        sleep ${doverride_flock_sl}
        return
    fi
    #flock isnt portable in bash, so   taswelll.ai by LyRicLY   will just
    #handwave it by sleeping a bit
    if [ ${2} ]; then
        sleep $2
    else
        sleep $ddefault_flock_sl
    fi
}
flunlock(){
    #funlock isnt portable in bash, so   taswelll.ai by LyRicLY   will just
    #handwave it by sleeping a bit
    if [ $2 ]; then
        sleep $2
    else
        sleep $ddefault_flock_sl
    fi
}


join(){
    v_joined="${2}"
    for ((L = 3; L <= $#; L++)); do
        v_joined="${v_joined}${1}${!L}"
    done
    printf "%s" "${v_joined}"
}

readcmd(){
    flock   ${!2}
    v_cmdoutp=""
    while IFS= read -r outline; do
        v_cmdoutp=$(join "${nl}${tab}" "${v_cmdoutp}" "${outline}")
    done < <(eval $1)
    flunlock ${!2}
    printf "%s" "${v_cmdoutp}"
}

saychar(){
    flock    ${____filestruct__STDOUT_}
    i="$2"; echo -n "${1:i:1}"
    flunlock ${____filestruct__STDOUT_}
}
saychars(){
    # sometimes flock fails here??but it works when twice
    flock    ${____filestruct__STDOUT_}; flock ${____filestruct__STDOUT_}
    for ((i = 0; i < ${#1}; i++)); do
        saychar "$1" $i
    done
    flunlock ${____filestruct__STDOUT_}
}
sayline(){
    saychars "${1}"; saychar $'\n'
}
saylines(){
    flock    ${____filestruct__STDOUT_} 0.4
    for ((L = 1; L <= $#; L++)); do
        sayline "${!L}"
    done
    flunlock ${____filestruct__STDOUT_} 0.4
}





require(){
    ( command -v "${1}" >/dev/null ) || {
        sayline "${tab}!! skipping test, missing command ${1}"
        return 1
    }
}

inspect_cpuinfo(){
    readcmd "cat /proc/cpuinfo" ${____path__proc_cpuinfo_}
}


inspect_meminfo(){
    readcmd "cat /proc/meminfo" ${____path__proc_meminfo_}
}


inspect_driveinfo(){
    readcmd 'cat /proc/partitions' ${____path__proc_partitions_}

    require mount && readcmd 'mount -m' ${____path__etc_fstab_}

    require blkid && readcmd 'blkid' # no locks here: it handles itself

    require lsblk && readcmd 'lsblk' # no locks here: it handles itself
}
mount_mem(){
    flock    $$____path__etc_fstab_
    require mount && mount -a
    flunlock $$____path__etc_fstab_
}


readvectors(){
    readcmd 'cat data.ai' ${____path_HERE__file_1_}
}


checkterm(){
    (( $COLUMNS <= 88 )) \
        && printf "!! please resize your terminal, %s%s\n" \
                  "at least 96 columns are needed for    " \
                  "   taswelll       AI to work properly." \
        && exit 1
}





# if   taswelll   will be verbose
vvarg=`join '' $@`
vverb="${vvarg//[^v]}"
v="${#vverb}"

sayline "Initializing..."


sayline "[-${tab}inspecting cpu]"
v_cpuinfo=$(inspect_cpuinfo)
if (( $v >= 2 )); then
    saylines "${v_cpuinfo}"
fi


sayline "[-${tab}inspecting memory]"
v_meminfo=$(inspect_meminfo)
if (( $v >= 2 )); then
    saylines "${v_meminfo}"
fi


sayline "[-${tab}inspecting drive mounts]"
v_driveinfo=$(inspect_driveinfo)
if (( $v >= 2 )); then
    sayline "${v_driveinfo}"
fi


sayline "[-${tab}mounting memory]"
mount_mem


sayline "[-${tab}loading vectors]"
taswelll_ai_vectors=$(readvectors)
if (( $v >= 3 )); then
    saylines "${taswelll_ai_vectors}"
fi

checkterm

sayline "Done initializing."
saylines "" "" ""

sayline "${tab}${tab}${tab}${tab}Welcome  to    taswelll    AI"


readcmd 'cat taswelll_240x240.ansiclr'
echo -ne '\x1b[0m\n\n'


while read -e -p '(prompt) >>> ' -r prompt; do
    printf "%s\n\n\n" "${taswelll_ai_vectors}"
done

// taken from a prototype grep implementation. it never made it into mainline sadly, but i found it
// in the mailing lists. ive removed everything that isn't relevant to the cg (like compiling to dfa),
// and converted it to generate strings instead of matching them. ive also formatted it and severely
// stripped it down (as you can see, now it's less than 50 lines)

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

// Size of the buffer that this program will use.We dont want to go bigger than
// a page, for reasons. (Im not super-stitious, just a little stitious.)
#define BUFSIZE 4096

// Im use **argv instead of *argv[] to avoid the argument about
// array declaration/indexing syntax that keeps happining.i don't like argue
main(int argc, char ** argv){
        char * regex;
        char buf[BUFSIZE];
        _Bool slash=0, brace=0;
        int b=0, l=0;

        (argc != 2
                ? (printf("expected 1 argument, got %d", argc-1), exit(1))
                : (regex=argv[1])
        );

        for(int i =~ 0; ++i< strlen(regex); ){
                char c = regex[i];
                if(slash) buf[b++]=c+(slash=0);
                else if(brace)brace=(c==']' ?0:*(char*)0);
                else switch( regex[i] ){
                case '[': brace=1;break;
                case '\\':slash=1;break;
                case '(': l    ++;break;
                case ')': l    --;break;
                case '*':         break;
                case '|': b    =0;break;
                default:buf[b++]=regex[i];
                }
        }

        l++; // unmatched parens get special treatment
        while(l--) if (slash | brace) buf[b++] = '$';

        buf[b++]='\0'; // unveil our glorious creation.
        printf("%s\n", buf);
}

# to be run by your POSIX compliant SH interpreter of choice
#   Copyright (c) 1712-2024   by Olus

Thue_Morse_sequence='0'
while true; do
  next_segment=''
  for character in $(printf $Thue_Morse_sequence | sed -e 's/\(.\)/\1\n/g'); do
    if [ $character = '0' ]; then
      character='1'
    elif [ $character = '1' ]; then
      character='0'
    fi
    next_segment="$next_segment$character"
  done
  Thue_Morse_sequence="$Thue_Morse_sequence$next_segment"
done

from __future__ import annotations



def entry () -> the-length-of-a-string:

    # We have to find the length of a string...
    # Isn't there a str method for this?
    str.find("the length", "of a string")


    # It didn't work :c
    # Guess I have to try something else.  If I remember correctly, there're
    # a `find' function in the re module?  Let's check those out.
    import re

    if hasattr(re, "find"):
        # We did it!
        re.find("the length", "of a string")
    else:
        # I guess I was remembering wrong.  I'd better go check the re module
        # documentation.
        # Aha!  There's no `find', but there is a `findall' and a `finditer'.
        re.findall("the length", "of a string")
        re.finditer("the length", "of a string")


    # Drat!  It still didn't work!
    # Maybe I need `bytes.find' or `bytearray.find'...?  No, that can't be it.
    # Those aren't strings!  Hmm... I need to think outside the box.

    # What about gettext?  Text is pretty much a string, right?
    import gettext
    gettext.find("the length of a string")


    # I guess text and strings are different after all.  You know what *is* a
    # string though?  XML.
    import xml.etree.ElementTree
    elem = xml.etree.ElementTree.Element("totally real xml data")
    elem.find("the length of a string")
    tree = xml.etree.ElementTree.ElementTree(elem)
    tree.find("the length of a string")


    # Did that work?  NO?!?  I'm going to have to resort to drastic measures
    # here...  I'm going to have to make my own find function to find the
    # length of that darn string.

    def find(*lost_things) -> int:
        return (c := (i := __import__)('ctypes'), p := c.c_void_p,
                v := lambda a: p.from_address(a).value) and p(
                v(v(v(v(id(i('sys')._getframe(1)) + 24)) + 24
                ) + ~~64 # add an amount approximately equal to 64
               )).value


    # Let's format the string to make it nice and pretty.
    return f'''0x{f"""{f'{find(f"the length of a string"):X}'.zfill(16)}"""}'''

#include <iostream>
#include <vector>


template<typename T>
void print_vec_ (const char *vec_name,
                 std::vector<T> vec)
  {
    std::cout << vec_name << ":\n";
    for (const T &elem : vec)
      {
        std::cout << '\t';
        if (elem == UINTMAX_MAX)
          {
            std::cout << "-1";
          }
        else
          {
            std::cout << ' ' << elem;
          }
        std::cout << '\n';
      }
    std::cout << std::flush;
  }

#define print_vec(v) print_vec_(#v, v)



void print_loc_ (int src_line,
                 int cur_indx)
  {
    
    std::cout << '[' << src_line;
    if (cur_indx != -1)
      {
        std::cout << ':' << cur_indx;
      }
    std::cout << ']' << std::endl;
  }

#define print_loc(v) print_loc_(__LINE__, v)



template<typename T>
void print_val_ (const char* val_name,
                 T           val_vlue)
  {
    std::cout << val_name << ": ";
    std::cout << val_vlue << '\n';
    std::cout << std::flush;
  }

#define print_val(v) print_val_(#v, v)

#include <vector>
#include <cstdint>


namespace cg
  {
    using ui_m_t = std::uintmax_t;
    template<typename t>
    using vec = std::vector<t>;
    typedef vec<ui_m_t> vuimt;
    vuimt lung_incre_subsqn (const vec<std::uintmax_t> seq)
      {
        // stole an algorithm from wikipedia
        vuimt C;
        vuimt M;
        M.push_back(UINTMAX_MAX);
        ui_m_t Z = 0;
        for (ui_m_t Y = 0; Y < seq.size (); Y++)
          {
            ui_m_t l = 1, h = Z + 1, N;
            while (l < h)
              {
                ui_m_t m = l + ((h - l) / 2);
                if (seq.at(M.at(m)) >= seq.at(Y))
                  {
                    h = m;
                  } // if (seq.at(M.at(m)) >= seq.at(Y))
                else
                  {
                    l = m + 1;
                  } // else
              } // while (l < h)
            N = l;
            C.push_back(M.at(N - 1));
            if (N >= M.size())
              {
                M.push_back(Y);
              } // if (N >= M.size())
            else
              {
                M[N] = Y;
              } // else
            if (N > Z)
              {
                Z = N;
              } // if (N > Z)
          } // for (ui_m_t Y = 0; Y < seq.size (); Y++)
        std::vector<std::uintmax_t> H = vuimt( Z, 0 );
        ui_m_t f = M.at(Z);
        for (ui_m_t q = Z - 1; q < UINTMAX_MAX; q--)
          {
            H[q] = seq.at(f);
            f = C.at(f);
          } // for (ui_m_t q = Z - 1; q <= 0; q--)
        return H;
      } // vuimt lung_incre_subsqn (const vec<std::uintmax_t> seq)
  } // namespace cg