#define TRUE   1
#define FALSE  0
#define OK     1
#define ERROR  0
#define  IBFEASIBLE  -1
#define  OVERFLOW    -2  
typedef  int   Status;

#define  errInt   -999

typedef struct {
   char *sv;      
   int   len;     
   int   size;    
} *LStr;          

int random1i(int x) {  
   if (x<0) return 0;
   else return (int)rand() % x;
}

int random2i( int x, int y ) { 
   if (x>=y) return x;
   else return (int)rand() % (y-x) + x;      
}

void get_anystr( int x, int y, char* str ) { 
    int i, len;
    char ch; 
    bool find;
    len = random2i(x, y);
    str[0] = 'A' + random1i(26);
    for (i=1; i<len; i++) {
       do {
          find = false;
          ch = 'A' + random1i(26);
          for (int j=0;  j<i && !find; j++)
             if (ch == str[j])
                find = true;
       } while (find);
       str[i] = ch;
    }
    str[len] = '\0';
}

void get_anystr_lc( int x, int y, char* str ) { 
    int i, len;
    char ch; 
    bool find;
    len = random2i(x, y);
    str[0] = 'a' + random1i(26);
    for (i=1; i<len; i++) {
       do {
          find = false;
          ch = 'a' + random1i(26);
          for (int j=0;  j<i && !find; j++)
             if (ch == str[j])
                find = true;
       } while (find);
       str[i] = ch;
    }
    str[len] = '\0';
}

LStr LStrFree(LStr S) {
   if (S) { free(S->sv);   free(S); }  
   return NULL;
}

LStr allocLStr(int size) {
   LStr S;
   if (!(S = (LStr)malloc((size+1)*sizeof(*S)))) exit(OVERFLOW);
   return S;
}

LStr LStrNew(char *cs) {  
   LStr S;   int len;   char *c;
   for (len=0, c=cs; *c++; ++len);  
   if (!(S = (LStr)malloc(sizeof(*S)))) exit(OVERFLOW); 
   if (0==len) { S->sv = NULL;   S->len = 0;   return S; }   
   if (!(S->sv = (char*)malloc((len+1)*sizeof(char)))) exit(OVERFLOW); 
   //for(i=0; j<len; i++) S->sv[i] = chars[i];
   memmove(S->sv, cs, len);                         
   S->len = S->size = len;   S->sv[len] = '\0';     
   return S;                                        
}
     
LStr LStrCreateRandom(int len, int c_l) {
   LStr S;
   if (!(S = (LStr)malloc(sizeof(*S)))) exit(OVERFLOW);  
   int n = (unsigned char)random2i(len/2, len);
   if (!(S->sv = (char*)malloc((n+1)*sizeof(char)))) exit(OVERFLOW);
   S->len = n;
   for (int i=0; i<n; i++)             
      S->sv[i] = c_l ? 'A'+random1i(26) : 'a'+random1i(26); 
   S->sv[n] = '\0';                    
   return S;
}

LStr LStrCopy(LStr S) {  
   if (!S) return NULL;       
   LStr T;
   if (!(T = (LStr)malloc(sizeof(*T)))) exit(OVERFLOW); 
   if (S->sv==NULL) { T->sv = NULL;   T->len = 0; }  
   else {                                               
      if (!(T->sv = (char*)malloc((S->len+1)*sizeof(char)))) exit(OVERFLOW);
      //for(int i=0; i<=S->len; i++) T->sv[i] = S->sv[i]; 
      memmove(T->sv, S->sv, S->len);                 
      T->len = S->len;                              
   }
   return T;
}

int LStrLen(LStr S) {  
   if (!S) return 0;              
   return S->len; 
}

int LStrCmp(LStr S, LStr T) {  
   
   char *s, *t;
   for (s=S->sv, t=T->sv; *s == *t; s++, t++) 
      if (*s=='\0') return 0;             
   return (int)*s - *t;                        
}

Status LStrClear(LStr S) {  
   if (!S) return ERROR;
   free(S->sv);   S->sv = NULL;   S->len = 0;
   return OK;
}

LStr LStrSub(LStr S, int pos, int len) {
   
   
   if (!S || pos<1 || pos>S->len || len<1 || len>S->len-pos+1) return NULL; 
   LStr Sub;
   if (!(Sub = (LStr)malloc(sizeof(*Sub)))) exit(OVERFLOW);  
   if (!(Sub->sv = (char *)malloc((len+1)*sizeof(char)))) exit(OVERFLOW); 
   memcpy(Sub->sv, S->sv+pos-1, len);  
   // for(int i=0; i<len ; i++) Sub->sv[i] = S->sv[pos-1+i];  
   Sub->len = len;   Sub->sv[len] = '\0';                  
   return Sub;
}

LStr LStrAssign(LStr S, int pos, char *cs) {  
   int len;   char *c;
   if (!S || pos<1 || pos>S->len+1) return S;    
   for (len=0, c=cs; *c++; ++len);  
   if (0==len) return S;            
   if (S->len < pos+len-1) S->len = pos+len-1;   
   if (S->len > S->size) {                       
      if (S->size >= 1024) S->size += 1024;    
      else S->size = 2*S->len;                 
      if (!(S->sv = (char*)realloc(S->sv, (S->size+1)*sizeof(char)))) exit(OVERFLOW); 
   }   
   memcpy(S->sv+pos-1, cs, len);                        
   S->sv[S->len] = '\0';                              
   return S;                                       
}


Status LStrInsert(LStr S, int pos, char *cs) {    
   if (!S || pos < 1 || pos > S->len+1) return ERROR; 
   int len;    char* c;
   for (len=0, c=cs; *c++;  ++len);             
   if (!len ) return OK;                            
   if (S->len + len > S->size) {                  
      char *oldsv = S->sv;                          
      if (S->size >= 1024) S->size += 1024;      
      else S->size = 2*(S->len + len);        
      if (!(S->sv = (char*)malloc((S->size+1)*sizeof(char)))) exit(OVERFLOW); 
      memcpy(S->sv, oldsv, pos-1);                                  
      memcpy(S->sv+pos-1+len, oldsv+pos-1, S->len-pos+2);      
      free(oldsv);                                                     
   } else  
      memmove(S->sv+pos-1+len, S->sv+pos-1, S->len-pos+2);     
   memcpy(S->sv+pos-1, cs, len);                                   
   S->len += len;                                                      
   return OK;
}

void LStrPrintf(char *title, LStr S) {   
   printf("%s->len = %2d; ", title, S->len);
   printf("%s = \"%s\"\n", title, S->sv);
}