API tools faq
paste
Advertisement
Guest User

Generated C

a guest
Jan 12th, 2020
138
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 37.60 KB | None | 0 0
raw download clone embed print report
  1. #define __FLAG_debug 0
  2. #include <stddef.h>
  3. #include <inttypes.h>
  4. #include <time.h>
  5. #include <stdbool.h>
  6. #include <stdlib.h>
  7. #include <stdio.h>
  8. #include <string.h>
  9.  
  10. static uint64_t __staticRandomNumber__;
  11.  
  12. static uint64_t __argc;
  13. static char** __argv;
  14.  
  15. struct t0 {uint64_t length; uint64_t capacity; uint64_t initCapacity; uint8_t* array; uint8_t* items; uint64_t* useCounter; bool isString;};
  16.  
  17. static inline void p__main0__4__52_0_5();
  18. static inline void p__free0__0__f__4__19_293_5(struct t0 slice_);
  19. static inline void p__printLn0__0__f__4__31_821_5(struct t0 a1_);
  20. static inline struct t0 f__toString0__0__f__5__19_3103_5(struct t0 slice_);
  21. static inline struct t0 f__toString0__0__f__4__19_3106_5(struct t0 slice_);
  22. static inline void p__addEq0__0__t__1__f__4__19_38_5(struct t0* slice_, uint8_t newItem_);
  23. static  __attribute__((always_inline)) void p__setStringFlag0__0__t__4__19_2792_5(struct t0* slice_);
  24. static  __attribute__((always_inline)) void p__setItem0__0__t__3__f__1__f__4__19_2831_5(struct t0* slice_, uint64_t index_, uint8_t newItem_);
  25. static  __attribute__((always_inline)) void p__use0__1__f__3__0_0_0(uint8_t a_);
  26. static inline struct t0 f__clone0__0__f__4__19_110_5(struct t0 slice_);
  27. static  __attribute__((always_inline)) bool f__string2__0__f__4__19_3079_5(struct t0 slice_);
  28. static  __attribute__((always_inline)) bool f__equal0__3__f__3__f__3__43_29_5(uint64_t a_, uint64_t b_);
  29. static  __attribute__((always_inline)) uint64_t f__getTypeNumber0__1__f__4__34_11_5(uint8_t a_);
  30. static inline void p__copyToFirst0__0__t__0__f__4__19_165_5(struct t0* slice_, struct t0 source_);
  31. static inline void p__copy0__0__t__3__f__3__f__0__f__4__19_144_5(struct t0* slice_, uint64_t from_, uint64_t to_, struct t0 source_);
  32. static  __attribute__((always_inline)) uint64_t f__getTypeSize0__1__f__4__34_5_5(uint8_t a_);
  33. static  __attribute__((always_inline)) bool f__use2__0__f__4__19_3127_5(struct t0 slice_);
  34. static  __attribute__((always_inline)) bool f__notEqual0__3__f__3__f__3__14_4_5(uint64_t a_, uint64_t b_);
  35. static  __attribute__((always_inline)) bool f__neg0__2__f__4__22_22_5(bool a_);
  36. static  __attribute__((always_inline)) uint64_t f__sub0__3__f__3__f__3__43_65_5(uint64_t a_, uint64_t b_);
  37. static  __attribute__((noinline)) void p__debugMessage0__2__f__0__f__4__24_0_5(bool predicate_, struct t0 message_);
  38. static inline void p__printLn0__0__f__0__f__4__31_828_5(struct t0 a1_, struct t0 a2_);
  39. static  __attribute__((always_inline)) bool f__greater0__3__f__3__f__3__43_35_5(uint64_t a_, uint64_t b_);
  40. static  __attribute__((always_inline)) uint64_t f__getLength0__0__f__4__19_426_5(struct t0 slice_);
  41. static  __attribute__((always_inline)) uint64_t f__convertTo0__3__f__3__f__8__34_0_5(uint64_t from_, uint64_t to_);
  42. static  __attribute__((always_inline)) struct t0 f__init0__0__f__3__f__4__19_508_5(struct t0 sliceType_, uint64_t numberOfItems_);
  43. static  __attribute__((always_inline)) struct t0 f__dummy0__0__f__3__f__4__19_248_5(struct t0 sliceType_, uint64_t numberOfItems_);
  44. static  __attribute__((always_inline)) bool f__greaterOrEqual0__3__f__3__f__3__43_41_5(uint64_t a_, uint64_t b_);
  45. static  __attribute__((always_inline)) struct t0 f__getFirstN0__0__f__3__f__4__19_344_5(struct t0 slice_, uint64_t n_);
  46. static  __attribute__((always_inline)) struct t0 f__getSlice0__0__f__3__f__3__f__4__19_432_5(struct t0 slice_, uint64_t from_, uint64_t to_);
  47. static  __attribute__((always_inline)) void p__use0__0__f__4__19_3119_5(struct t0 slice_);
  48. static  __attribute__((always_inline)) uint64_t f__add0__3__f__3__f__3__43_15_5(uint64_t a_, uint64_t b_);
  49. static  __attribute__((always_inline)) uint64_t f__mul0__3__f__3__f__3__43_59_5(uint64_t a_, uint64_t b_);
  50. static  __attribute__((always_inline)) uint64_t f__div0__3__f__3__f__3__43_21_5(uint64_t a_, uint64_t b_);
  51. static  __attribute__((always_inline)) bool f__lessOrEqual0__3__f__3__f__3__43_53_5(uint64_t a_, uint64_t b_);
  52. static  __attribute__((always_inline)) uint64_t f__getCapacity0__0__f__4__19_333_5(struct t0 slice_);
  53. static  __attribute__((always_inline)) struct t0 f__getAllExceptLastN0__0__f__3__f__4__19_328_5(struct t0 slice_, uint64_t n_);
  54. static inline void p__join0__0__t__0__f__0__f__4__19_1259_5(struct t0* slice_, struct t0 js1_, struct t0 js2_);
  55. static inline void p__addEq0__0__t__0__f__4__19_53_5(struct t0* slice_, struct t0 lastPart_);
  56. static inline void p__copyToLast0__0__t__0__f__4__19_168_5(struct t0* slice_, struct t0 source_);
  57. static  __attribute__((always_inline)) bool f__less0__3__f__3__f__3__43_47_5(uint64_t a_, uint64_t b_);
  58. static  __attribute__((always_inline)) struct t0 f__toString0__1__f__3__16_80_5(uint8_t a_);
  59. static  __attribute__((always_inline)) uint8_t f__parse_item0__0__f__3__f__4__19_2777_5(struct t0 slice_, uint64_t index_);
  60. static  __attribute__((always_inline)) uint8_t f__getItem0__0__f__3__f__4__19_407_5(struct t0 slice_, uint64_t index_);
  61. static  __attribute__((always_inline)) bool f__parse_haveItem2__0__f__3__f__4__19_2772_5(struct t0 slice_, uint64_t index_);
  62. static  __attribute__((always_inline)) uint64_t f__parse_next0__0__f__3__f__4__19_2787_5(struct t0 slice_, uint64_t index_);
  63. static  __attribute__((always_inline)) uint64_t f__parse_first0__0__f__4__19_2767_5(struct t0 slice_);
  64. static  __attribute__((always_inline)) void p__setFirst0__0__t__1__f__4__19_2826_5(struct t0* slice_, uint8_t newItem_);
  65.  
  66. int main(int argc, char** argv) {
  67.     if (sizeof(float) != 4 || sizeof(double) != 8) {
  68.         printf("Only platforms in which the float type has a size of 32 bits and the double type has a size of 64 bits are supported.\n");
  69.     }
  70.     srand(time(NULL) + 17313770734317324529ull);
  71.     __staticRandomNumber__ = rand();
  72.     __argc = argc;
  73.     __argv = argv;
  74.     p__main0__4__52_0_5();
  75.     return 0;
  76. }
  77.  
  78. static inline void p__main0__4__52_0_5() {
  79.     {
  80.     int __breakCounter = 0;
  81.     int __continueCounter = 0;
  82.     struct t0 a_ = (struct t0){.length = strlen("hello"), .capacity = strlen("hello"), .array = (uint8_t*){0}, .items = (uint8_t*)"hello", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true};
  83.     p__use0__0__f__4__19_3119_5(a_);
  84.     struct t0 b_ = a_;
  85.     p__use0__0__f__4__19_3119_5(a_);
  86.     struct t0 c_ = a_;
  87.     struct t0 const __r0 = b_;
  88.     b_ = (struct t0){.length = strlen("hello 2"), .capacity = strlen("hello 2"), .array = (uint8_t*){0}, .items = (uint8_t*)"hello 2", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true};
  89.     p__free0__0__f__4__19_293_5(__r0);
  90.     p__setFirst0__0__t__1__f__4__19_2826_5(&c_, (uint8_t)'H');
  91.     p__printLn0__0__f__4__31_821_5(a_);
  92.     p__printLn0__0__f__4__31_821_5(b_);
  93.     p__printLn0__0__f__4__31_821_5(c_);
  94.     p__free0__0__f__4__19_293_5(a_);
  95.     p__free0__0__f__4__19_293_5(b_);
  96.     p__free0__0__f__4__19_293_5(c_);
  97.     }
  98. }
  99.  
  100. static inline void p__free0__0__f__4__19_293_5(struct t0 slice_) {
  101.     {
  102.     int __breakCounter = 0;
  103.     int __continueCounter = 0;
  104.     bool needToFree_ = false;
  105.     if (slice_.useCounter != (uint64_t*){0}) {
  106.     needToFree_ = *slice_.useCounter < 2;
  107.     (*slice_.useCounter)--;
  108.     }
  109.     {
  110.     if (needToFree_) {
  111.     {
  112.     }
  113.     free(slice_.useCounter);
  114.     free(slice_.array);
  115.     }
  116.     }
  117.     }
  118. }
  119.  
  120. static inline void p__printLn0__0__f__4__31_821_5(struct t0 a1_) {
  121.     {
  122.     int __breakCounter = 0;
  123.     int __continueCounter = 0;
  124.     struct t0 const __r0 = f__toString0__0__f__5__19_3103_5(a1_);
  125.     struct t0 const str1_ = __r0;
  126.     printf("%.*s\n", (int)(str1_.length), (char*)(str1_.items));
  127.     p__free0__0__f__4__19_293_5(str1_);
  128.     }
  129. }
  130.  
  131. static inline struct t0 f__toString0__0__f__5__19_3103_5(struct t0 slice_) {
  132.     {
  133.     int __breakCounter = 0;
  134.     int __continueCounter = 0;
  135.     struct t0 result_ = (struct t0){0};
  136.     bool const __r0 = f__string2__0__f__4__19_3079_5(slice_);
  137.     struct t0 __r1;
  138.     if (__r0){
  139.     p__use0__0__f__4__19_3119_5(slice_);
  140.     __r1 = slice_;
  141.     } else {
  142.     struct t0 const __r2 = f__toString0__0__f__4__19_3106_5(slice_);
  143.     __r1 = __r2;
  144.     }
  145.     struct t0 const __r3 = result_;
  146.     result_ = __r1;
  147.     p__free0__0__f__4__19_293_5(__r3);
  148.     return result_;
  149.     }
  150. }
  151.  
  152. static inline struct t0 f__toString0__0__f__4__19_3106_5(struct t0 slice_) {
  153.     {
  154.     int __breakCounter = 0;
  155.     int __continueCounter = 0;
  156.     struct t0 result_ = (struct t0){0};
  157.     struct t0 const __r0 = result_;
  158.     result_ = (struct t0){.length = strlen("["), .capacity = strlen("["), .array = (uint8_t*){0}, .items = (uint8_t*)"[", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true};
  159.     p__free0__0__f__4__19_293_5(__r0);
  160.     {
  161.     uint64_t const __r1 = f__getLength0__0__f__4__19_426_5(slice_);
  162.     bool const __r2 = f__notEqual0__3__f__3__f__3__14_4_5(__r1, (uint64_t)0ull);
  163.     if (__r2) {
  164.     {
  165.     uint64_t const __r3 = f__parse_first0__0__f__4__19_2767_5(slice_);
  166.     uint64_t __r4 = __r3;
  167.     bool __firstTime = true;
  168.     for (;;){
  169.     if (!__firstTime){
  170.     uint64_t const __r5 = f__parse_next0__0__f__3__f__4__19_2787_5(slice_, __r4);
  171.     __r4 = __r5;
  172.     } else {    __firstTime = false;}
  173.     bool const __r6 = f__parse_haveItem2__0__f__3__f__4__19_2772_5(slice_, __r4);
  174.     if (!__r6){break;};
  175.     uint8_t const __r7 = f__parse_item0__0__f__3__f__4__19_2777_5(slice_, __r4);
  176.     uint8_t const item_ = __r7;
  177.     struct t0 const __r8 = f__toString0__1__f__3__16_80_5(__r7);
  178.     p__join0__0__t__0__f__0__f__4__19_1259_5(&result_, __r8, (struct t0){.length = strlen(", "), .capacity = strlen(", "), .array = (uint8_t*){0}, .items = (uint8_t*)", ", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  179.     p__free0__0__f__4__19_293_5(__r8);
  180.     }
  181.     }
  182.     struct t0 const __r9 = f__getAllExceptLastN0__0__f__3__f__4__19_328_5(result_, (uint64_t)2ull);
  183.     struct t0 const __r10 = result_;
  184.     result_ = __r9;
  185.     p__free0__0__f__4__19_293_5(__r10);
  186.     }
  187.     }
  188.     p__addEq0__0__t__1__f__4__19_38_5(&result_, (uint8_t)']');
  189.     return result_;
  190.     }
  191. }
  192.  
  193. static inline void p__addEq0__0__t__1__f__4__19_38_5(struct t0* slice_, uint8_t newItem_) {
  194.     {
  195.     int __breakCounter = 0;
  196.     int __continueCounter = 0;
  197.     uint64_t const __r0 = f__getLength0__0__f__4__19_426_5((*slice_));
  198.     uint64_t const initLength_ = __r0;
  199.     bool const __r1 = f__string2__0__f__4__19_3079_5((*slice_));
  200.     bool const isString_ = __r1;
  201.     {
  202.     uint64_t const __r2 = f__getCapacity0__0__f__4__19_333_5((*slice_));
  203.     bool const __r3 = f__lessOrEqual0__3__f__3__f__3__43_53_5(__r2, initLength_);
  204.     bool __r4 = __r3;
  205.     if (!__r4) {
  206.     bool const __r5 = f__use2__0__f__4__19_3127_5((*slice_));
  207.     __r4 = __r5;
  208.     }
  209.     if (__r4) {
  210.     uint64_t const __r6 = f__div0__3__f__3__f__3__43_21_5(initLength_, (uint64_t)4ull);
  211.     uint64_t const __r7 = f__add0__3__f__3__f__3__43_15_5(initLength_, __r6);
  212.     uint64_t const __r8 = f__div0__3__f__3__f__3__43_21_5(__r7, (uint64_t)64ull);
  213.     uint64_t const __r9 = f__add0__3__f__3__f__3__43_15_5(__r8, (uint64_t)1ull);
  214.     uint64_t const __r10 = f__mul0__3__f__3__f__3__43_59_5(__r9, (uint64_t)64ull);
  215.     struct t0 const __r11 = f__init0__0__f__3__f__4__19_508_5((struct t0){0}, __r10);
  216.     struct t0 newSlice_ = __r11;
  217.     p__copyToFirst0__0__t__0__f__4__19_165_5(&newSlice_, (*slice_));
  218.     uint64_t const __r12 = f__add0__3__f__3__f__3__43_15_5(initLength_, (uint64_t)1ull);
  219.     struct t0 const __r13 = f__getFirstN0__0__f__3__f__4__19_344_5(newSlice_, __r12);
  220.     struct t0 const __r14 = (*slice_);
  221.     *(slice_) = __r13;
  222.     p__free0__0__f__4__19_293_5(__r14);
  223.     p__free0__0__f__4__19_293_5(newSlice_);
  224.     } else {
  225.     slice_->length++;
  226.     }
  227.     }
  228.     p__setItem0__0__t__3__f__1__f__4__19_2831_5(slice_, initLength_, newItem_);
  229.     {
  230.     if (isString_) {
  231.     p__setStringFlag0__0__t__4__19_2792_5(slice_);
  232.     }
  233.     }
  234.     }
  235. }
  236.  
  237. static  __attribute__((always_inline)) void p__setStringFlag0__0__t__4__19_2792_5(struct t0* slice_) {
  238.     {
  239.     int __breakCounter = 0;
  240.     int __continueCounter = 0;
  241.     slice_->isString = true;
  242.     }
  243. }
  244.  
  245. static  __attribute__((always_inline)) void p__setItem0__0__t__3__f__1__f__4__19_2831_5(struct t0* slice_, uint64_t index_, uint8_t newItem_) {
  246.     {
  247.     int __breakCounter = 0;
  248.     int __continueCounter = 0;
  249.     {
  250.     #if __FLAG_debug == 1
  251.     uint64_t const __r0 = f__convertTo0__3__f__3__f__8__34_0_5(index_, (uint64_t){0});
  252.     uint64_t const __r1 = f__getLength0__0__f__4__19_426_5((*slice_));
  253.     bool const __r2 = f__greaterOrEqual0__3__f__3__f__3__43_41_5(__r0, __r1);
  254.     p__debugMessage0__2__f__0__f__4__24_0_5(__r2, (struct t0){.length = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 2836. UB - the index is too large."), .capacity = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 2836. UB - the index is too large."), .array = (uint8_t*){0}, .items = (uint8_t*)"File: /opt/cine/modules/standart/Slice.cine, line: 2836. UB - the index is too large.", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  255.     #endif
  256.     }
  257.     {
  258.     bool const __r3 = f__use2__0__f__4__19_3127_5((*slice_));
  259.     if (__r3) {
  260.     struct t0 const __r4 = f__clone0__0__f__4__19_110_5((*slice_));
  261.     struct t0 const __r5 = (*slice_);
  262.     *(slice_) = __r4;
  263.     p__free0__0__f__4__19_293_5(__r5);
  264.     }
  265.     }
  266.     uint8_t oldItem_ = (uint8_t){0};
  267.     oldItem_ = slice_->items[index_];
  268.     slice_->items[index_] = newItem_;
  269.     p__use0__1__f__3__0_0_0(newItem_);
  270.     }
  271. }
  272.  
  273. static  __attribute__((always_inline)) void p__use0__1__f__3__0_0_0(uint8_t a_) {
  274.     {
  275.     int __breakCounter = 0;
  276.     int __continueCounter = 0;
  277.     }
  278. }
  279.  
  280. static inline struct t0 f__clone0__0__f__4__19_110_5(struct t0 slice_) {
  281.     {
  282.     int __breakCounter = 0;
  283.     int __continueCounter = 0;
  284.     struct t0 result_ = (struct t0){0};
  285.     {
  286.     uint64_t const __r0 = f__getLength0__0__f__4__19_426_5(slice_);
  287.     bool const __r1 = f__notEqual0__3__f__3__f__3__14_4_5(__r0, (uint64_t)0ull);
  288.     if (__r1) {
  289.     uint64_t const __r2 = f__getLength0__0__f__4__19_426_5(slice_);
  290.     struct t0 const __r3 = f__init0__0__f__3__f__4__19_508_5((struct t0){0}, __r2);
  291.     struct t0 const __r4 = result_;
  292.     result_ = __r3;
  293.     p__free0__0__f__4__19_293_5(__r4);
  294.     p__copyToFirst0__0__t__0__f__4__19_165_5(&result_, slice_);
  295.     }
  296.     }
  297.     {
  298.     bool const __r5 = f__string2__0__f__4__19_3079_5(slice_);
  299.     if (__r5) {
  300.     p__setStringFlag0__0__t__4__19_2792_5(&result_);
  301.     }
  302.     }
  303.     return result_;
  304.     }
  305. }
  306.  
  307. static  __attribute__((always_inline)) bool f__string2__0__f__4__19_3079_5(struct t0 slice_) {
  308.     {
  309.     int __breakCounter = 0;
  310.     int __continueCounter = 0;
  311.     bool result_ = (bool){0};
  312.     {
  313.     uint64_t const __r0 = f__getTypeNumber0__1__f__4__34_11_5((uint8_t){0});
  314.     uint64_t const __r1 = f__getTypeNumber0__1__f__4__34_11_5((uint8_t){0});
  315.     bool const __r2 = f__equal0__3__f__3__f__3__43_29_5(__r0, __r1);
  316.     if (__r2) {
  317.     result_ = slice_.isString;
  318.     }
  319.     }
  320.     return result_;
  321.     }
  322. }
  323.  
  324. static  __attribute__((always_inline)) bool f__equal0__3__f__3__f__3__43_29_5(uint64_t a_, uint64_t b_) {
  325.     {
  326.     int __breakCounter = 0;
  327.     int __continueCounter = 0;
  328.     bool result_ = (bool){0};
  329.     result_ = a_ == b_;
  330.     return result_;
  331.     }
  332. }
  333.  
  334. static  __attribute__((always_inline)) uint64_t f__getTypeNumber0__1__f__4__34_11_5(uint8_t a_) {
  335.     {
  336.     int __breakCounter = 0;
  337.     int __continueCounter = 0;
  338.     uint64_t result_ = (uint64_t){0};
  339.     result_ = (uint64_t)1ull;
  340.     return result_;
  341.     }
  342. }
  343.  
  344. static inline void p__copyToFirst0__0__t__0__f__4__19_165_5(struct t0* slice_, struct t0 source_) {
  345.     {
  346.     int __breakCounter = 0;
  347.     int __continueCounter = 0;
  348.     uint64_t const __r0 = f__getLength0__0__f__4__19_426_5(source_);
  349.     p__copy0__0__t__3__f__3__f__0__f__4__19_144_5(slice_, (uint64_t)0ull, __r0, source_);
  350.     }
  351. }
  352.  
  353. static inline void p__copy0__0__t__3__f__3__f__0__f__4__19_144_5(struct t0* slice_, uint64_t from_, uint64_t to_, struct t0 source_) {
  354.     {
  355.     int __breakCounter = 0;
  356.     int __continueCounter = 0;
  357.     {
  358.     #if __FLAG_debug == 1
  359.     uint64_t const __r0 = f__convertTo0__3__f__3__f__8__34_0_5(from_, (uint64_t){0});
  360.     uint64_t const __r1 = f__convertTo0__3__f__3__f__8__34_0_5(to_, (uint64_t){0});
  361.     bool const __r2 = f__greater0__3__f__3__f__3__43_35_5(__r0, __r1);
  362.     p__debugMessage0__2__f__0__f__4__24_0_5(__r2, (struct t0){.length = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 150. UB - the first index is greater than the last index."), .capacity = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 150. UB - the first index is greater than the last index."), .array = (uint8_t*){0}, .items = (uint8_t*)"File: /opt/cine/modules/standart/Slice.cine, line: 150. UB - the first index is greater than the last index.", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  363.     uint64_t const __r3 = f__convertTo0__3__f__3__f__8__34_0_5(from_, (uint64_t){0});
  364.     uint64_t const __r4 = f__getLength0__0__f__4__19_426_5((*slice_));
  365.     bool const __r5 = f__greater0__3__f__3__f__3__43_35_5(__r3, __r4);
  366.     p__debugMessage0__2__f__0__f__4__24_0_5(__r5, (struct t0){.length = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 151. UB - the first index is too large."), .capacity = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 151. UB - the first index is too large."), .array = (uint8_t*){0}, .items = (uint8_t*)"File: /opt/cine/modules/standart/Slice.cine, line: 151. UB - the first index is too large.", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  367.     uint64_t const __r6 = f__convertTo0__3__f__3__f__8__34_0_5(to_, (uint64_t){0});
  368.     uint64_t const __r7 = f__getLength0__0__f__4__19_426_5((*slice_));
  369.     bool const __r8 = f__greater0__3__f__3__f__3__43_35_5(__r6, __r7);
  370.     p__debugMessage0__2__f__0__f__4__24_0_5(__r8, (struct t0){.length = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 152. UB - the last index is too large."), .capacity = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 152. UB - the last index is too large."), .array = (uint8_t*){0}, .items = (uint8_t*)"File: /opt/cine/modules/standart/Slice.cine, line: 152. UB - the last index is too large.", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  371.     uint64_t const __r9 = f__convertTo0__3__f__3__f__8__34_0_5(to_, (uint64_t){0});
  372.     uint64_t const __r10 = f__convertTo0__3__f__3__f__8__34_0_5(from_, (uint64_t){0});
  373.     uint64_t const __r11 = f__sub0__3__f__3__f__3__43_65_5(__r9, __r10);
  374.     uint64_t const __r12 = f__getLength0__0__f__4__19_426_5(source_);
  375.     bool const __r13 = f__greater0__3__f__3__f__3__43_35_5(__r11, __r12);
  376.     p__debugMessage0__2__f__0__f__4__24_0_5(__r13, (struct t0){.length = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 153. UB - the source is too short."), .capacity = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 153. UB - the source is too short."), .array = (uint8_t*){0}, .items = (uint8_t*)"File: /opt/cine/modules/standart/Slice.cine, line: 153. UB - the source is too short.", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  377.     #endif
  378.     }
  379.     {
  380.     uint64_t const __r14 = f__sub0__3__f__3__f__3__43_65_5(to_, from_);
  381.     uint64_t const length_ = __r14;
  382.     bool const __r15 = f__notEqual0__3__f__3__f__3__14_4_5(length_, (uint64_t)0ull);
  383.     if (__r15) {
  384.     {
  385.     {
  386.     bool const __r16 = f__use2__0__f__4__19_3127_5((*slice_));
  387.     if (__r16) {
  388.     struct t0 const __r17 = f__clone0__0__f__4__19_110_5((*slice_));
  389.     struct t0 const __r18 = (*slice_);
  390.     *(slice_) = __r17;
  391.     p__free0__0__f__4__19_293_5(__r18);
  392.     }
  393.     }
  394.     uint64_t const __r19 = f__getTypeSize0__1__f__4__34_5_5((uint8_t){0});
  395.     uint64_t const itemSize_ = __r19;
  396.     memcpy(slice_->items + from_, source_.items, length_ * itemSize_);
  397.     }
  398.     }
  399.     }
  400.     }
  401. }
  402.  
  403. static  __attribute__((always_inline)) uint64_t f__getTypeSize0__1__f__4__34_5_5(uint8_t a_) {
  404.     {
  405.     int __breakCounter = 0;
  406.     int __continueCounter = 0;
  407.     uint64_t result_ = (uint64_t){0};
  408.     result_ = sizeof(uint8_t);
  409.     return result_;
  410.     }
  411. }
  412.  
  413. static  __attribute__((always_inline)) bool f__use2__0__f__4__19_3127_5(struct t0 slice_) {
  414.     {
  415.     int __breakCounter = 0;
  416.     int __continueCounter = 0;
  417.     bool result_ = (bool){0};
  418.     if (slice_.useCounter != (uint64_t*){0}) {
  419.     result_ = *slice_.useCounter > 1;
  420.     }
  421.     result_ = result_ || ((void*)slice_.array == (void*){0} && (void*)slice_.items != (void*){0});
  422.     return result_;
  423.     }
  424. }
  425.  
  426. static  __attribute__((always_inline)) bool f__notEqual0__3__f__3__f__3__14_4_5(uint64_t a_, uint64_t b_) {
  427.     {
  428.     int __breakCounter = 0;
  429.     int __continueCounter = 0;
  430.     bool result_ = (bool){0};
  431.     bool const __r0 = f__equal0__3__f__3__f__3__43_29_5(a_, b_);
  432.     bool const __r1 = f__neg0__2__f__4__22_22_5(__r0);
  433.     result_ = __r1;
  434.     return result_;
  435.     }
  436. }
  437.  
  438. static  __attribute__((always_inline)) bool f__neg0__2__f__4__22_22_5(bool a_) {
  439.     {
  440.     int __breakCounter = 0;
  441.     int __continueCounter = 0;
  442.     bool result_ = (bool){0};
  443.     result_ = !a_;
  444.     return result_;
  445.     }
  446. }
  447.  
  448. static  __attribute__((always_inline)) uint64_t f__sub0__3__f__3__f__3__43_65_5(uint64_t a_, uint64_t b_) {
  449.     {
  450.     int __breakCounter = 0;
  451.     int __continueCounter = 0;
  452.     uint64_t result_ = (uint64_t){0};
  453.     result_ = a_ - b_;
  454.     return result_;
  455.     }
  456. }
  457.  
  458. static  __attribute__((noinline)) void p__debugMessage0__2__f__0__f__4__24_0_5(bool predicate_, struct t0 message_) {
  459.     {
  460.     int __breakCounter = 0;
  461.     int __continueCounter = 0;
  462.     {
  463.     #if __FLAG_debug == 1
  464.     {
  465.     if (predicate_) {
  466.     p__printLn0__0__f__0__f__4__31_828_5((struct t0){.length = strlen("DEBUG: "), .capacity = strlen("DEBUG: "), .array = (uint8_t*){0}, .items = (uint8_t*)"DEBUG: ", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true}, message_);
  467.     }
  468.     }
  469.     #endif
  470.     }
  471.     }
  472. }
  473.  
  474. static inline void p__printLn0__0__f__0__f__4__31_828_5(struct t0 a1_, struct t0 a2_) {
  475.     {
  476.     int __breakCounter = 0;
  477.     int __continueCounter = 0;
  478.     struct t0 const __r0 = f__toString0__0__f__5__19_3103_5(a1_);
  479.     struct t0 const str1_ = __r0;
  480.     struct t0 const __r1 = f__toString0__0__f__5__19_3103_5(a2_);
  481.     struct t0 const str2_ = __r1;
  482.     printf("%.*s%.*s\n", (int)(str1_.length), (char*)(str1_.items), (int)(str2_.length), (char*)(str2_.items));
  483.     p__free0__0__f__4__19_293_5(str1_);
  484.     p__free0__0__f__4__19_293_5(str2_);
  485.     }
  486. }
  487.  
  488. static  __attribute__((always_inline)) bool f__greater0__3__f__3__f__3__43_35_5(uint64_t a_, uint64_t b_) {
  489.     {
  490.     int __breakCounter = 0;
  491.     int __continueCounter = 0;
  492.     bool result_ = (bool){0};
  493.     result_ = a_ > b_;
  494.     return result_;
  495.     }
  496. }
  497.  
  498. static  __attribute__((always_inline)) uint64_t f__getLength0__0__f__4__19_426_5(struct t0 slice_) {
  499.     {
  500.     int __breakCounter = 0;
  501.     int __continueCounter = 0;
  502.     uint64_t result_ = (uint64_t){0};
  503.     result_ = slice_.length;
  504.     return result_;
  505.     }
  506. }
  507.  
  508. static  __attribute__((always_inline)) uint64_t f__convertTo0__3__f__3__f__8__34_0_5(uint64_t from_, uint64_t to_) {
  509.     {
  510.     int __breakCounter = 0;
  511.     int __continueCounter = 0;
  512.     uint64_t result_ = (uint64_t){0};
  513.     result_ = from_;
  514.     return result_;
  515.     }
  516. }
  517.  
  518. static  __attribute__((always_inline)) struct t0 f__init0__0__f__3__f__4__19_508_5(struct t0 sliceType_, uint64_t numberOfItems_) {
  519.     {
  520.     int __breakCounter = 0;
  521.     int __continueCounter = 0;
  522.     struct t0 result_ = (struct t0){0};
  523.     struct t0 const __r0 = f__dummy0__0__f__3__f__4__19_248_5((struct t0){0}, numberOfItems_);
  524.     struct t0 const __r1 = result_;
  525.     result_ = __r0;
  526.     p__free0__0__f__4__19_293_5(__r1);
  527.     result_.length = numberOfItems_;
  528.     return result_;
  529.     }
  530. }
  531.  
  532. static  __attribute__((always_inline)) struct t0 f__dummy0__0__f__3__f__4__19_248_5(struct t0 sliceType_, uint64_t numberOfItems_) {
  533.     {
  534.     int __breakCounter = 0;
  535.     int __continueCounter = 0;
  536.     struct t0 result_ = (struct t0){0};
  537.     {
  538.     bool const __r0 = f__notEqual0__3__f__3__f__3__14_4_5(numberOfItems_, (uint64_t)0ull);
  539.     if (__r0) {
  540.     result_.array = (uint8_t*)calloc(numberOfItems_, sizeof(uint8_t));
  541.     result_.useCounter = (uint64_t*)(malloc(sizeof(uint64_t)));
  542.     if (__builtin_expect(result_.array == NULL || result_.useCounter == NULL, false)){
  543.     fprintf(stderr, "Not enought memory.\n");
  544.     abort();
  545.     }
  546.     *result_.useCounter = 1;
  547.     result_.items = result_.array;
  548.     result_.capacity = numberOfItems_;
  549.     result_.initCapacity = numberOfItems_;
  550.     }
  551.     }
  552.     return result_;
  553.     }
  554. }
  555.  
  556. static  __attribute__((always_inline)) bool f__greaterOrEqual0__3__f__3__f__3__43_41_5(uint64_t a_, uint64_t b_) {
  557.     {
  558.     int __breakCounter = 0;
  559.     int __continueCounter = 0;
  560.     bool result_ = (bool){0};
  561.     result_ = a_ >= b_;
  562.     return result_;
  563.     }
  564. }
  565.  
  566. static  __attribute__((always_inline)) struct t0 f__getFirstN0__0__f__3__f__4__19_344_5(struct t0 slice_, uint64_t n_) {
  567.     {
  568.     int __breakCounter = 0;
  569.     int __continueCounter = 0;
  570.     struct t0 result_ = (struct t0){0};
  571.     struct t0 const __r0 = f__getSlice0__0__f__3__f__3__f__4__19_432_5(slice_, (uint64_t)0ull, n_);
  572.     struct t0 const __r1 = result_;
  573.     result_ = __r0;
  574.     p__free0__0__f__4__19_293_5(__r1);
  575.     return result_;
  576.     }
  577. }
  578.  
  579. static  __attribute__((always_inline)) struct t0 f__getSlice0__0__f__3__f__3__f__4__19_432_5(struct t0 slice_, uint64_t from_, uint64_t to_) {
  580.     {
  581.     int __breakCounter = 0;
  582.     int __continueCounter = 0;
  583.     struct t0 result_ = (struct t0){0};
  584.     {
  585.     #if __FLAG_debug == 1
  586.     uint64_t const __r0 = f__convertTo0__3__f__3__f__8__34_0_5(from_, (uint64_t){0});
  587.     uint64_t const __r1 = f__convertTo0__3__f__3__f__8__34_0_5(to_, (uint64_t){0});
  588.     bool const __r2 = f__greater0__3__f__3__f__3__43_35_5(__r0, __r1);
  589.     p__debugMessage0__2__f__0__f__4__24_0_5(__r2, (struct t0){.length = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 440. UB - the first index is greater than the last index."), .capacity = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 440. UB - the first index is greater than the last index."), .array = (uint8_t*){0}, .items = (uint8_t*)"File: /opt/cine/modules/standart/Slice.cine, line: 440. UB - the first index is greater than the last index.", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  590.     uint64_t const __r3 = f__convertTo0__3__f__3__f__8__34_0_5(from_, (uint64_t){0});
  591.     uint64_t const __r4 = f__getLength0__0__f__4__19_426_5(slice_);
  592.     bool const __r5 = f__greater0__3__f__3__f__3__43_35_5(__r3, __r4);
  593.     p__debugMessage0__2__f__0__f__4__24_0_5(__r5, (struct t0){.length = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 441. UB - the first index is too large."), .capacity = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 441. UB - the first index is too large."), .array = (uint8_t*){0}, .items = (uint8_t*)"File: /opt/cine/modules/standart/Slice.cine, line: 441. UB - the first index is too large.", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  594.     uint64_t const __r6 = f__convertTo0__3__f__3__f__8__34_0_5(to_, (uint64_t){0});
  595.     uint64_t const __r7 = f__getLength0__0__f__4__19_426_5(slice_);
  596.     bool const __r8 = f__greater0__3__f__3__f__3__43_35_5(__r6, __r7);
  597.     p__debugMessage0__2__f__0__f__4__24_0_5(__r8, (struct t0){.length = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 442. UB - the last index is too large."), .capacity = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 442. UB - the last index is too large."), .array = (uint8_t*){0}, .items = (uint8_t*)"File: /opt/cine/modules/standart/Slice.cine, line: 442. UB - the last index is too large.", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  598.     #endif
  599.     }
  600.     uint64_t const __r9 = f__sub0__3__f__3__f__3__43_65_5(to_, from_);
  601.     uint64_t const newLength_ = __r9;
  602.     {
  603.     bool const __r10 = f__notEqual0__3__f__3__f__3__14_4_5(newLength_, (uint64_t)0ull);
  604.     if (__r10) {
  605.     result_.length = newLength_;
  606.     result_.capacity = slice_.capacity - from_;
  607.     result_.array = slice_.array;
  608.     result_.initCapacity = slice_.initCapacity;
  609.     result_.items = slice_.items + from_;
  610.     result_.useCounter = slice_.useCounter;
  611.     p__use0__0__f__4__19_3119_5(result_);
  612.     }
  613.     }
  614.     {
  615.     bool const __r11 = f__string2__0__f__4__19_3079_5(slice_);
  616.     if (__r11) {
  617.     p__setStringFlag0__0__t__4__19_2792_5(&result_);
  618.     }
  619.     }
  620.     return result_;
  621.     }
  622. }
  623.  
  624. static  __attribute__((always_inline)) void p__use0__0__f__4__19_3119_5(struct t0 slice_) {
  625.     {
  626.     int __breakCounter = 0;
  627.     int __continueCounter = 0;
  628.     if (slice_.useCounter != (uint64_t*){0}) {
  629.     (*slice_.useCounter)++;
  630.     }
  631.     }
  632. }
  633.  
  634. static  __attribute__((always_inline)) uint64_t f__add0__3__f__3__f__3__43_15_5(uint64_t a_, uint64_t b_) {
  635.     {
  636.     int __breakCounter = 0;
  637.     int __continueCounter = 0;
  638.     uint64_t result_ = (uint64_t){0};
  639.     result_ = a_ + b_;
  640.     return result_;
  641.     }
  642. }
  643.  
  644. static  __attribute__((always_inline)) uint64_t f__mul0__3__f__3__f__3__43_59_5(uint64_t a_, uint64_t b_) {
  645.     {
  646.     int __breakCounter = 0;
  647.     int __continueCounter = 0;
  648.     uint64_t result_ = (uint64_t){0};
  649.     result_ = a_ * b_;
  650.     return result_;
  651.     }
  652. }
  653.  
  654. static  __attribute__((always_inline)) uint64_t f__div0__3__f__3__f__3__43_21_5(uint64_t a_, uint64_t b_) {
  655.     {
  656.     int __breakCounter = 0;
  657.     int __continueCounter = 0;
  658.     uint64_t result_ = (uint64_t){0};
  659.     {
  660.     #if __FLAG_debug == 1
  661.     bool const __r0 = f__equal0__3__f__3__f__3__43_29_5(b_, (uint64_t)0ull);
  662.     p__debugMessage0__2__f__0__f__4__24_0_5(__r0, (struct t0){.length = strlen("File: /opt/cine/modules/standart/BasicNumber.cine, line: 26. UB - division by zero."), .capacity = strlen("File: /opt/cine/modules/standart/BasicNumber.cine, line: 26. UB - division by zero."), .array = (uint8_t*){0}, .items = (uint8_t*)"File: /opt/cine/modules/standart/BasicNumber.cine, line: 26. UB - division by zero.", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  663.     #endif
  664.     }
  665.     result_ = a_ / b_;
  666.     return result_;
  667.     }
  668. }
  669.  
  670. static  __attribute__((always_inline)) bool f__lessOrEqual0__3__f__3__f__3__43_53_5(uint64_t a_, uint64_t b_) {
  671.     {
  672.     int __breakCounter = 0;
  673.     int __continueCounter = 0;
  674.     bool result_ = (bool){0};
  675.     result_ = a_ <= b_;
  676.     return result_;
  677.     }
  678. }
  679.  
  680. static  __attribute__((always_inline)) uint64_t f__getCapacity0__0__f__4__19_333_5(struct t0 slice_) {
  681.     {
  682.     int __breakCounter = 0;
  683.     int __continueCounter = 0;
  684.     uint64_t result_ = (uint64_t){0};
  685.     result_ = slice_.capacity;
  686.     return result_;
  687.     }
  688. }
  689.  
  690. static  __attribute__((always_inline)) struct t0 f__getAllExceptLastN0__0__f__3__f__4__19_328_5(struct t0 slice_, uint64_t n_) {
  691.     {
  692.     int __breakCounter = 0;
  693.     int __continueCounter = 0;
  694.     struct t0 result_ = (struct t0){0};
  695.     uint64_t const __r0 = f__getLength0__0__f__4__19_426_5(slice_);
  696.     uint64_t const __r1 = f__convertTo0__3__f__3__f__8__34_0_5(n_, (uint64_t){0});
  697.     uint64_t const __r2 = f__sub0__3__f__3__f__3__43_65_5(__r0, __r1);
  698.     struct t0 const __r3 = f__getSlice0__0__f__3__f__3__f__4__19_432_5(slice_, (uint64_t)0ull, __r2);
  699.     struct t0 const __r4 = result_;
  700.     result_ = __r3;
  701.     p__free0__0__f__4__19_293_5(__r4);
  702.     return result_;
  703.     }
  704. }
  705.  
  706. static inline void p__join0__0__t__0__f__0__f__4__19_1259_5(struct t0* slice_, struct t0 js1_, struct t0 js2_) {
  707.     {
  708.     int __breakCounter = 0;
  709.     int __continueCounter = 0;
  710.     uint64_t const __r0 = f__getLength0__0__f__4__19_426_5((*slice_));
  711.     uint64_t const __r1 = f__getLength0__0__f__4__19_426_5(js1_);
  712.     uint64_t const __r2 = f__add0__3__f__3__f__3__43_15_5(__r0, __r1);
  713.     uint64_t const __r3 = f__getLength0__0__f__4__19_426_5(js2_);
  714.     uint64_t const __r4 = f__add0__3__f__3__f__3__43_15_5(__r2, __r3);
  715.     uint64_t const length_ = __r4;
  716.     {
  717.     bool const __r5 = f__use2__0__f__4__19_3127_5((*slice_));
  718.     bool __r6 = __r5;
  719.     if (!__r6) {
  720.     uint64_t const __r7 = f__getCapacity0__0__f__4__19_333_5((*slice_));
  721.     bool const __r8 = f__less0__3__f__3__f__3__43_47_5(__r7, length_);
  722.     __r6 = __r8;
  723.     }
  724.     if (__r6) {
  725.     uint64_t const __r9 = f__div0__3__f__3__f__3__43_21_5(length_, (uint64_t)4ull);
  726.     uint64_t const __r10 = f__add0__3__f__3__f__3__43_15_5(length_, __r9);
  727.     uint64_t const __r11 = f__div0__3__f__3__f__3__43_21_5(__r10, (uint64_t)64ull);
  728.     uint64_t const __r12 = f__add0__3__f__3__f__3__43_15_5(__r11, (uint64_t)1ull);
  729.     uint64_t const __r13 = f__mul0__3__f__3__f__3__43_59_5(__r12, (uint64_t)64ull);
  730.     struct t0 const __r14 = f__dummy0__0__f__3__f__4__19_248_5((struct t0){0}, __r13);
  731.     struct t0 newSlice_ = __r14;
  732.     {
  733.     bool const __r15 = f__string2__0__f__4__19_3079_5((*slice_));
  734.     if (__r15) {
  735.     p__setStringFlag0__0__t__4__19_2792_5(&newSlice_);
  736.     }
  737.     }
  738.     p__addEq0__0__t__0__f__4__19_53_5(&newSlice_, (*slice_));
  739.     p__use0__0__f__4__19_3119_5(newSlice_);
  740.     struct t0 const __r16 = (*slice_);
  741.     *(slice_) = newSlice_;
  742.     p__free0__0__f__4__19_293_5(__r16);
  743.     p__free0__0__f__4__19_293_5(newSlice_);
  744.     }
  745.     }
  746.     p__addEq0__0__t__0__f__4__19_53_5(slice_, js1_);
  747.     p__addEq0__0__t__0__f__4__19_53_5(slice_, js2_);
  748.     }
  749. }
  750.  
  751. static inline void p__addEq0__0__t__0__f__4__19_53_5(struct t0* slice_, struct t0 lastPart_) {
  752.     {
  753.     int __breakCounter = 0;
  754.     int __continueCounter = 0;
  755.     uint64_t const __r0 = f__getLength0__0__f__4__19_426_5((*slice_));
  756.     uint64_t const __r1 = f__getLength0__0__f__4__19_426_5(lastPart_);
  757.     uint64_t const __r2 = f__add0__3__f__3__f__3__43_15_5(__r0, __r1);
  758.     uint64_t const newLength_ = __r2;
  759.     bool const __r3 = f__string2__0__f__4__19_3079_5((*slice_));
  760.     bool const isString_ = __r3;
  761.     {
  762.     uint64_t const __r4 = f__getCapacity0__0__f__4__19_333_5((*slice_));
  763.     bool const __r5 = f__less0__3__f__3__f__3__43_47_5(__r4, newLength_);
  764.     bool __r6 = __r5;
  765.     if (!__r6) {
  766.     bool const __r7 = f__use2__0__f__4__19_3127_5((*slice_));
  767.     __r6 = __r7;
  768.     }
  769.     if (__r6) {
  770.     uint64_t const __r8 = f__div0__3__f__3__f__3__43_21_5(newLength_, (uint64_t)4ull);
  771.     uint64_t const __r9 = f__add0__3__f__3__f__3__43_15_5(newLength_, __r8);
  772.     uint64_t const __r10 = f__div0__3__f__3__f__3__43_21_5(__r9, (uint64_t)64ull);
  773.     uint64_t const __r11 = f__add0__3__f__3__f__3__43_15_5(__r10, (uint64_t)1ull);
  774.     uint64_t const __r12 = f__mul0__3__f__3__f__3__43_59_5(__r11, (uint64_t)64ull);
  775.     struct t0 const __r13 = f__init0__0__f__3__f__4__19_508_5((struct t0){0}, __r12);
  776.     struct t0 newSlice_ = __r13;
  777.     p__copyToFirst0__0__t__0__f__4__19_165_5(&newSlice_, (*slice_));
  778.     struct t0 const __r14 = f__getFirstN0__0__f__3__f__4__19_344_5(newSlice_, newLength_);
  779.     struct t0 const __r15 = (*slice_);
  780.     *(slice_) = __r14;
  781.     p__free0__0__f__4__19_293_5(__r15);
  782.     p__free0__0__f__4__19_293_5(newSlice_);
  783.     } else {
  784.     slice_->length = newLength_;
  785.     }
  786.     }
  787.     p__copyToLast0__0__t__0__f__4__19_168_5(slice_, lastPart_);
  788.     {
  789.     if (isString_) {
  790.     p__setStringFlag0__0__t__4__19_2792_5(slice_);
  791.     }
  792.     }
  793.     }
  794. }
  795.  
  796. static inline void p__copyToLast0__0__t__0__f__4__19_168_5(struct t0* slice_, struct t0 source_) {
  797.     {
  798.     int __breakCounter = 0;
  799.     int __continueCounter = 0;
  800.     uint64_t const __r0 = f__getLength0__0__f__4__19_426_5((*slice_));
  801.     uint64_t const __r1 = f__getLength0__0__f__4__19_426_5(source_);
  802.     uint64_t const __r2 = f__sub0__3__f__3__f__3__43_65_5(__r0, __r1);
  803.     uint64_t const __r3 = f__getLength0__0__f__4__19_426_5((*slice_));
  804.     p__copy0__0__t__3__f__3__f__0__f__4__19_144_5(slice_, __r2, __r3, source_);
  805.     }
  806. }
  807.  
  808. static  __attribute__((always_inline)) bool f__less0__3__f__3__f__3__43_47_5(uint64_t a_, uint64_t b_) {
  809.     {
  810.     int __breakCounter = 0;
  811.     int __continueCounter = 0;
  812.     bool result_ = (bool){0};
  813.     result_ = a_ < b_;
  814.     return result_;
  815.     }
  816. }
  817.  
  818. static  __attribute__((always_inline)) struct t0 f__toString0__1__f__3__16_80_5(uint8_t a_) {
  819.     {
  820.     int __breakCounter = 0;
  821.     int __continueCounter = 0;
  822.     struct t0 result_ = (struct t0){0};
  823.     uint64_t const __r0 = f__getTypeSize0__1__f__4__34_5_5((uint8_t){0});
  824.     uint64_t const __r1 = f__mul0__3__f__3__f__3__43_59_5(__r0, (uint64_t)3ull);
  825.     uint64_t const __r2 = f__getTypeSize0__1__f__4__34_5_5((uint8_t){0});
  826.     uint64_t const __r3 = f__div0__3__f__3__f__3__43_21_5(__r2, (uint64_t)2ull);
  827.     uint64_t const __r4 = f__sub0__3__f__3__f__3__43_65_5(__r1, __r3);
  828.     uint64_t length_ = __r4;
  829.     uint64_t index_ = length_;
  830.     uint8_t remain_ = a_;
  831.     char tmpResult[length_];
  832.     for (;;){
  833.     index_--;
  834.     char newChar = remain_ % 10 + 48;
  835.     remain_ /= 10;
  836.     tmpResult[index_] = newChar;
  837.     if (remain_ == 0){
  838.     break;
  839.     }
  840.     }
  841.     length_ -= index_;
  842.     struct t0 const __r5 = f__init0__0__f__3__f__4__19_508_5((struct t0){0}, length_);
  843.     struct t0 const __r6 = result_;
  844.     result_ = __r5;
  845.     p__free0__0__f__4__19_293_5(__r6);
  846.     memcpy(result_.items, tmpResult + index_, length_);
  847.     p__setStringFlag0__0__t__4__19_2792_5(&result_);
  848.     return result_;
  849.     }
  850. }
  851.  
  852. static  __attribute__((always_inline)) uint8_t f__parse_item0__0__f__3__f__4__19_2777_5(struct t0 slice_, uint64_t index_) {
  853.     {
  854.     int __breakCounter = 0;
  855.     int __continueCounter = 0;
  856.     uint8_t result_ = (uint8_t){0};
  857.     uint8_t const __r0 = f__getItem0__0__f__3__f__4__19_407_5(slice_, index_);
  858.     result_ = __r0;
  859.     return result_;
  860.     }
  861. }
  862.  
  863. static  __attribute__((always_inline)) uint8_t f__getItem0__0__f__3__f__4__19_407_5(struct t0 slice_, uint64_t index_) {
  864.     {
  865.     int __breakCounter = 0;
  866.     int __continueCounter = 0;
  867.     uint8_t result_ = (uint8_t){0};
  868.     {
  869.     #if __FLAG_debug == 1
  870.     uint64_t const __r0 = f__convertTo0__3__f__3__f__8__34_0_5(index_, (uint64_t){0});
  871.     uint64_t const __r1 = f__getLength0__0__f__4__19_426_5(slice_);
  872.     bool const __r2 = f__greaterOrEqual0__3__f__3__f__3__43_41_5(__r0, __r1);
  873.     p__debugMessage0__2__f__0__f__4__24_0_5(__r2, (struct t0){.length = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 412. UB - the index is too large."), .capacity = strlen("File: /opt/cine/modules/standart/Slice.cine, line: 412. UB - the index is too large."), .array = (uint8_t*){0}, .items = (uint8_t*)"File: /opt/cine/modules/standart/Slice.cine, line: 412. UB - the index is too large.", .initCapacity = 0, .useCounter = (uint64_t*){0}, .isString = true});
  874.     #endif
  875.     }
  876.     result_ = slice_.items[index_];
  877.     p__use0__1__f__3__0_0_0(result_);
  878.     return result_;
  879.     }
  880. }
  881.  
  882. static  __attribute__((always_inline)) bool f__parse_haveItem2__0__f__3__f__4__19_2772_5(struct t0 slice_, uint64_t index_) {
  883.     {
  884.     int __breakCounter = 0;
  885.     int __continueCounter = 0;
  886.     bool result_ = (bool){0};
  887.     uint64_t const __r0 = f__getLength0__0__f__4__19_426_5(slice_);
  888.     bool const __r1 = f__less0__3__f__3__f__3__43_47_5(index_, __r0);
  889.     result_ = __r1;
  890.     return result_;
  891.     }
  892. }
  893.  
  894. static  __attribute__((always_inline)) uint64_t f__parse_next0__0__f__3__f__4__19_2787_5(struct t0 slice_, uint64_t index_) {
  895.     {
  896.     int __breakCounter = 0;
  897.     int __continueCounter = 0;
  898.     uint64_t result_ = (uint64_t){0};
  899.     uint64_t const __r0 = f__add0__3__f__3__f__3__43_15_5(index_, (uint64_t)1ull);
  900.     result_ = __r0;
  901.     return result_;
  902.     }
  903. }
  904.  
  905. static  __attribute__((always_inline)) uint64_t f__parse_first0__0__f__4__19_2767_5(struct t0 slice_) {
  906.     {
  907.     int __breakCounter = 0;
  908.     int __continueCounter = 0;
  909.     uint64_t result_ = (uint64_t){0};
  910.     result_ = (uint64_t)0ull;
  911.     return result_;
  912.     }
  913. }
  914.  
  915. static  __attribute__((always_inline)) void p__setFirst0__0__t__1__f__4__19_2826_5(struct t0* slice_, uint8_t newItem_) {
  916.     {
  917.     int __breakCounter = 0;
  918.     int __continueCounter = 0;
  919.     p__setItem0__0__t__3__f__1__f__4__19_2831_5(slice_, (uint64_t)0ull, newItem_);
  920.     }
  921. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!