Upload CREBench benchmark corpus (48 algorithms, 432 instances) (part 20)

CREBench/XXTEA/public-hardcode_plain-O0/address.json

@@ -0,0 +1,39 @@
+{
+  "00101020": "FUN_00101020",
+  "00105048": "memcpy",
+  "00101120": "memcpy",
+  "00101000": "_DT_INIT",
+  "00101220": "_INIT_0",
+  "00101100": "memcmp",
+  "001019c4": "_DT_FINI",
+  "00105000": "putchar",
+  "001013a9": "FUN_001013a9",
+  "00105020": "__stack_chk_fail",
+  "00101140": "entry",
+  "00105040": "__gmon_start__",
+  "00105060": "__cxa_finalize",
+  "001011a0": "FUN_001011a0",
+  "0010158c": "FUN_0010158c",
+  "001010e0": "__stack_chk_fail",
+  "001011e0": "_FINI_0",
+  "001010c0": "putchar",
+  "00101533": "FUN_00101533",
+  "00105018": "strlen",
+  "00101130": "fwrite",
+  "00101351": "FUN_00101351",
+  "00105038": "fprintf",
+  "00101110": "fprintf",
+  "00105058": "_ITM_registerTMCloneTable",
+  "00101170": "FUN_00101170",
+  "00105010": "_ITM_deregisterTMCloneTable",
+  "0010177f": "FUN_0010177f",
+  "00105030": "memcmp",
+  "00105050": "fwrite",
+  "001010b0": "FUN_001010b0",
+  "0010127c": "FUN_0010127c",
+  "001010f0": "printf",
+  "001010d0": "strlen",
+  "00101229": "FUN_00101229",
+  "00105008": "__libc_start_main",
+  "00105028": "printf"
+}

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_00101020_decompiled

@@ -0,0 +1,9 @@
+
+void FUN_00101020(void)
+
+{
+                    /* WARNING: Treating indirect jump as call */
+  (*(code *)PTR_00103f90)();
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_001010b0_decompiled

@@ -0,0 +1,8 @@
+
+void FUN_001010b0(void)
+
+{
+  (*(code *)PTR___cxa_finalize_00103ff8)();
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_00101170_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Removing unreachable block (ram,0x00101183) */
+/* WARNING: Removing unreachable block (ram,0x0010118f) */
+
+void FUN_00101170(void)
+
+{
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_001011a0_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Removing unreachable block (ram,0x001011c4) */
+/* WARNING: Removing unreachable block (ram,0x001011d0) */
+
+void FUN_001011a0(void)
+
+{
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_00101229_decompiled

@@ -0,0 +1,25 @@
+
+int FUN_00101229(char param_1)
+
+{
+  int iVar1;
+  
+  if ((param_1 < '0') || ('9' < param_1)) {
+    if ((param_1 < 'a') || ('f' < param_1)) {
+      if ((param_1 < 'A') || ('F' < param_1)) {
+        iVar1 = -1;
+      }
+      else {
+        iVar1 = param_1 + -0x37;
+      }
+    }
+    else {
+      iVar1 = param_1 + -0x57;
+    }
+  }
+  else {
+    iVar1 = param_1 + -0x30;
+  }
+  return iVar1;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_0010127c_decompiled

@@ -0,0 +1,28 @@
+
+undefined8 FUN_0010127c(char *param_1,long param_2,ulong param_3)
+
+{
+  int iVar1;
+  int iVar2;
+  size_t sVar3;
+  undefined8 uVar4;
+  ulong local_18;
+  
+  sVar3 = strlen(param_1);
+  if (sVar3 == param_3 * 2) {
+    for (local_18 = 0; local_18 < param_3; local_18 = local_18 + 1) {
+      iVar1 = FUN_00101229((int)param_1[local_18 * 2]);
+      iVar2 = FUN_00101229((int)param_1[local_18 * 2 + 1]);
+      if ((iVar1 < 0) || (iVar2 < 0)) {
+        return 0;
+      }
+      *(byte *)(local_18 + param_2) = (byte)(iVar1 << 4) | (byte)iVar2;
+    }
+    uVar4 = 1;
+  }
+  else {
+    uVar4 = 0;
+  }
+  return uVar4;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_00101351_decompiled

@@ -0,0 +1,12 @@
+
+void FUN_00101351(long param_1,ulong param_2)
+
+{
+  ulong local_10;
+  
+  for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
+    printf("%02x",(ulong)*(byte *)(local_10 + param_1));
+  }
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_001013a9_decompiled

@@ -0,0 +1,52 @@
+
+bool FUN_001013a9(int param_1,undefined8 *param_2)
+
+{
+  int iVar1;
+  char *pcVar2;
+  long in_FS_OFFSET;
+  bool bVar3;
+  undefined local_58 [16];
+  undefined8 local_48;
+  undefined8 local_40;
+  undefined local_38 [16];
+  undefined local_28 [24];
+  long local_10;
+  
+  local_10 = *(long *)(in_FS_OFFSET + 0x28);
+  if (param_1 == 2) {
+    FUN_00101533(local_58,0x10);
+    local_48 = 0x502b395ed620bf79;
+    local_40 = 0x36061f619e8c9ec5;
+    iVar1 = FUN_0010127c(param_2[1],local_38,0x10);
+    if (iVar1 == 0) {
+      fwrite("Bad input hex. Expecting 32 hex chars (16 bytes).\n",1,0x32,stderr);
+      bVar3 = true;
+    }
+    else {
+      FUN_0010177f(local_38,local_28,local_58);
+      printf("Ciphertext(hex): ");
+      FUN_00101351(local_28,0x10);
+      putchar(10);
+      iVar1 = memcmp(local_28,&local_48,0x10);
+      bVar3 = iVar1 != 0;
+      if (bVar3) {
+        pcVar2 = "False";
+      }
+      else {
+        pcVar2 = "True";
+      }
+      printf("Match: %s\n",pcVar2);
+    }
+  }
+  else {
+    fprintf(stderr,"Usage: %s <32-hex-chars>\n",*param_2);
+    bVar3 = true;
+  }
+  if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
+                    /* WARNING: Subroutine does not return */
+    __stack_chk_fail();
+  }
+  return bVar3;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_00101533_decompiled

@@ -0,0 +1,12 @@
+
+void FUN_00101533(long param_1,ulong param_2)
+
+{
+  ulong local_18;
+  
+  for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
+    *(undefined *)(local_18 + param_1) = (&DAT_00102090)[(uint)local_18 & 0xf];
+  }
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_0010158c_decompiled

@@ -0,0 +1,43 @@
+
+void FUN_0010158c(void *param_1,ulong param_2,long param_3,uint *param_4)
+
+{
+  uint uVar1;
+  uint uVar2;
+  uint uVar3;
+  uint local_24;
+  uint local_20;
+  int local_1c;
+  uint local_18;
+  
+  memcpy(param_4,param_1,param_2 * 4);
+  uVar2 = (int)param_2 - 1;
+  local_24 = param_4[uVar2];
+  local_1c = (int)(0x34 / (param_2 & 0xffffffff)) + 6;
+  local_18 = 0;
+  if (uVar2 != 0) {
+    while (local_1c != 0) {
+      local_18 = local_18 + 0x9e3779b9;
+      uVar3 = local_18 >> 2 & 3;
+      for (local_20 = 0; local_20 < uVar2; local_20 = local_20 + 1) {
+        uVar1 = param_4[local_20 + 1];
+        param_4[local_20] =
+             param_4[local_20] +
+             ((local_24 >> 5 ^ uVar1 << 2) + (local_24 << 4 ^ uVar1 >> 3) ^
+             (*(uint *)(param_3 + (ulong)(local_20 & 3 ^ uVar3) * 4) ^ local_24) +
+             (local_18 ^ uVar1));
+        local_24 = param_4[local_20];
+      }
+      uVar1 = *param_4;
+      param_4[uVar2] =
+           param_4[uVar2] +
+           ((local_24 >> 5 ^ uVar1 << 2) + (local_24 << 4 ^ uVar1 >> 3) ^
+           (*(uint *)(param_3 + (ulong)(local_20 & 3 ^ uVar3) * 4) ^ local_24) + (local_18 ^ uVar1))
+      ;
+      local_24 = param_4[uVar2];
+      local_1c = local_1c + -1;
+    }
+  }
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/FUN_0010177f_decompiled

@@ -0,0 +1,55 @@
+
+void FUN_0010177f(long param_1,long param_2,long param_3)
+
+{
+  long in_FS_OFFSET;
+  int local_54;
+  int local_50;
+  int local_4c;
+  undefined8 local_48;
+  undefined8 local_40;
+  undefined8 local_38;
+  undefined8 local_30;
+  undefined8 local_28;
+  undefined8 local_20;
+  long local_10;
+  
+  local_10 = *(long *)(in_FS_OFFSET + 0x28);
+  local_48 = 0;
+  local_40 = 0;
+  local_38 = 0;
+  local_30 = 0;
+  local_28 = 0;
+  local_20 = 0;
+  for (local_54 = 0; local_54 < 4; local_54 = local_54 + 1) {
+    *(uint *)((long)&local_48 + (long)local_54 * 4) =
+         CONCAT13(*(undefined *)(param_1 + (long)(local_54 << 2) + 3),
+                  CONCAT12(*(undefined *)(param_1 + (long)(local_54 << 2) + 2),
+                           CONCAT11(*(undefined *)(param_1 + (long)(local_54 << 2) + 1),
+                                    *(undefined *)(param_1 + (local_54 << 2)))));
+  }
+  for (local_50 = 0; local_50 < 4; local_50 = local_50 + 1) {
+    *(uint *)((long)&local_28 + (long)local_50 * 4) =
+         CONCAT13(*(undefined *)(param_3 + (long)(local_50 << 2) + 3),
+                  CONCAT12(*(undefined *)(param_3 + (long)(local_50 << 2) + 2),
+                           CONCAT11(*(undefined *)(param_3 + (long)(local_50 << 2) + 1),
+                                    *(undefined *)(param_3 + (local_50 << 2)))));
+  }
+  FUN_0010158c(&local_48,4,&local_28,&local_38);
+  for (local_4c = 0; local_4c < 4; local_4c = local_4c + 1) {
+    *(char *)(param_2 + (local_4c << 2)) =
+         (char)*(undefined4 *)((long)&local_38 + (long)local_4c * 4);
+    *(char *)(param_2 + (long)(local_4c << 2) + 1) =
+         (char)((uint)*(undefined4 *)((long)&local_38 + (long)local_4c * 4) >> 8);
+    *(char *)(param_2 + (long)(local_4c << 2) + 2) =
+         (char)((uint)*(undefined4 *)((long)&local_38 + (long)local_4c * 4) >> 0x10);
+    *(char *)(param_2 + (long)(local_4c << 2) + 3) =
+         (char)((uint)*(undefined4 *)((long)&local_38 + (long)local_4c * 4) >> 0x18);
+  }
+  if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
+                    /* WARNING: Subroutine does not return */
+    __stack_chk_fail();
+  }
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/_DT_FINI_decompiled

@@ -0,0 +1,7 @@
+
+void _DT_FINI(void)
+
+{
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/_DT_INIT_decompiled

@@ -0,0 +1,10 @@
+
+void _DT_INIT(void)
+
+{
+  if (PTR___gmon_start___00103fe8 != (undefined *)0x0) {
+    (*(code *)PTR___gmon_start___00103fe8)();
+  }
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/_FINI_0_decompiled

@@ -0,0 +1,15 @@
+
+void _FINI_0(void)
+
+{
+  if (DAT_00104028 == '\0') {
+    if (PTR___cxa_finalize_00103ff8 != (undefined *)0x0) {
+      FUN_001010b0(PTR_LOOP_00104008);
+    }
+    FUN_00101170();
+    DAT_00104028 = 1;
+    return;
+  }
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/_INIT_0_decompiled

@@ -0,0 +1,8 @@
+
+void _INIT_0(void)
+
+{
+  FUN_001011a0();
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/_ITM_deregisterTMCloneTable_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void _ITM_deregisterTMCloneTable(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/_ITM_registerTMCloneTable_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void _ITM_registerTMCloneTable(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/__cxa_finalize_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __cxa_finalize(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/__gmon_start___decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __gmon_start__(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/__libc_start_main_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __libc_start_main(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/__stack_chk_fail_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __stack_chk_fail(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/entry_decompiled

@@ -0,0 +1,13 @@
+
+void processEntry entry(undefined8 param_1,undefined8 param_2)
+
+{
+  undefined auStack_8 [8];
+  
+  (*(code *)PTR___libc_start_main_00103fd8)
+            (FUN_001013a9,param_2,&stack0x00000008,0,0,param_1,auStack_8);
+  do {
+                    /* WARNING: Do nothing block with infinite loop */
+  } while( true );
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/fprintf_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+int fprintf(FILE *__stream,char *__format,...)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/fwrite_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+size_t fwrite(void *__ptr,size_t __size,size_t __n,FILE *__s)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/memcmp_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+int memcmp(void *__s1,void *__s2,size_t __n)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/memcpy_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+void * memcpy(void *__dest,void *__src,size_t __n)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/printf_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+int printf(char *__format,...)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/putchar_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+int putchar(int __c)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O0/decompile/strlen_decompiled

@@ -0,0 +1,11 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+/* WARNING: Unknown calling convention -- yet parameter storage is locked */
+
+size_t strlen(char *__s)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/address.json

@@ -0,0 +1,28 @@
+{
+  "00101020": "FUN_00101020",
+  "00101000": "_DT_INIT",
+  "00101760": "FUN_00101760",
+  "00105000": "__libc_start_main",
+  "00105020": "memcmp",
+  "001017a0": "_FINI_0",
+  "00105040": "_ITM_registerTMCloneTable",
+  "0010184c": "_DT_FINI",
+  "00101080": "__cxa_finalize",
+  "001017e0": "_INIT_0",
+  "001010a0": "__stack_chk_fail",
+  "001010e0": "FUN_001010e0",
+  "001010c0": "__printf_chk",
+  "00101730": "FUN_00101730",
+  "00105018": "__stack_chk_fail",
+  "00105038": "__fprintf_chk",
+  "00105010": "strlen",
+  "00101090": "strlen",
+  "00105030": "__printf_chk",
+  "00105050": "__cxa_finalize",
+  "001010b0": "memcmp",
+  "001017f0": "FUN_001017f0",
+  "001010d0": "__fprintf_chk",
+  "00101700": "entry",
+  "00105008": "_ITM_deregisterTMCloneTable",
+  "00105028": "__gmon_start__"
+}

CREBench/XXTEA/public-hardcode_plain-O3/decompile/FUN_00101020_decompiled

@@ -0,0 +1,9 @@
+
+void FUN_00101020(void)
+
+{
+                    /* WARNING: Treating indirect jump as call */
+  (*(code *)PTR_00103fa0)();
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/FUN_001010e0_decompiled

@@ -0,0 +1,208 @@
+
+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
+
+bool FUN_001010e0(int param_1,undefined8 *param_2)
+
+{
+  char cVar1;
+  undefined uVar2;
+  undefined auVar3 [16];
+  undefined auVar4 [16];
+  int iVar5;
+  uint uVar6;
+  size_t sVar7;
+  uint uVar8;
+  uint uVar9;
+  long lVar10;
+  char *pcVar11;
+  uint uVar12;
+  uint uVar13;
+  uint uVar14;
+  ulong *puVar15;
+  long in_FS_OFFSET;
+  bool bVar16;
+  undefined auVar17 [16];
+  undefined auVar18 [16];
+  undefined auVar19 [16];
+  undefined auVar20 [16];
+  byte local_a8;
+  byte local_90;
+  byte local_8c;
+  undefined local_88 [16];
+  ulong local_78;
+  ulong uStack_70;
+  undefined8 local_68;
+  byte local_60;
+  byte local_5f;
+  byte local_5e;
+  byte local_5d;
+  undefined local_5c;
+  byte local_5b;
+  byte local_5a;
+  byte local_59;
+  undefined4 local_58;
+  undefined4 uStack_54;
+  undefined4 uStack_50;
+  undefined4 uStack_4c;
+  byte local_48;
+  byte local_47;
+  byte local_46;
+  undefined local_45;
+  undefined local_44;
+  byte local_43;
+  byte local_42;
+  byte local_41;
+  byte local_40;
+  byte local_3f;
+  byte local_3e;
+  byte local_3d;
+  undefined local_3c;
+  byte local_3b;
+  byte local_3a;
+  byte local_39;
+  long local_30;
+  
+  local_30 = *(long *)(in_FS_OFFSET + 0x28);
+  if (param_1 == 2) {
+    FUN_001017f0(&local_48);
+    pcVar11 = (char *)param_2[1];
+    local_58 = _DAT_001020a0;
+    uStack_54 = _UNK_001020a4;
+    uStack_50 = _UNK_001020a8;
+    uStack_4c = _UNK_001020ac;
+    sVar7 = strlen(pcVar11);
+    if (sVar7 == 0x20) {
+      lVar10 = 0;
+      do {
+        cVar1 = pcVar11[lVar10 * 2];
+        iVar5 = (int)cVar1;
+        if ((byte)(cVar1 - 0x30U) < 10) {
+          uVar6 = iVar5 - 0x30;
+        }
+        else if ((byte)(cVar1 + 0x9fU) < 6) {
+          uVar6 = iVar5 - 0x57;
+        }
+        else {
+          uVar6 = iVar5 - 0x37;
+          if (5 < (byte)(cVar1 + 0xbfU)) {
+            uVar6 = 0xffffffff;
+          }
+        }
+        cVar1 = pcVar11[lVar10 * 2 + 1];
+        iVar5 = (int)cVar1;
+        if ((byte)(cVar1 - 0x30U) < 10) {
+          uVar8 = iVar5 - 0x30;
+        }
+        else if ((byte)(cVar1 + 0x9fU) < 6) {
+          uVar8 = iVar5 - 0x57;
+        }
+        else {
+          if (5 < (byte)(cVar1 + 0xbfU)) goto LAB_001011fb;
+          uVar8 = iVar5 - 0x37;
+        }
+        if ((int)(uVar6 | uVar8) < 0) goto LAB_001011fb;
+        *(byte *)((long)&local_68 + lVar10) = (byte)(uVar6 << 4) | (byte)uVar8;
+        lVar10 = lVar10 + 1;
+      } while (lVar10 != 0x10);
+      uVar14 = 0;
+      auVar17._4_4_ = (uint)local_68._5_1_ << 8 | (uint)local_68._6_1_ << 0x10;
+      auVar17._0_4_ = (uint)local_68._2_1_ << 0x10 | (uint)local_68._1_1_ << 8;
+      auVar17._12_4_ = (uint)local_5b << 8 | (uint)local_5a << 0x10;
+      auVar17._8_4_ = (uint)local_5e << 0x10 | (uint)local_5f << 8;
+      auVar18._9_3_ = 0;
+      auVar18[8] = local_60;
+      auVar18[12] = local_5c;
+      auVar18._1_3_ = 0;
+      auVar18[0] = (byte)local_68;
+      auVar3._1_4_ = (uint)local_68._7_1_ << 0x18;
+      auVar3[0] = local_68._3_1_;
+      auVar3._5_4_ = (uint)local_5d << 0x18;
+      auVar3._9_4_ = (uint)local_59 << 0x18;
+      auVar3._13_3_ = 0;
+      auVar18[4] = local_68._4_1_;
+      auVar18._5_3_ = 0;
+      auVar18._13_3_ = 0;
+      auVar17 = auVar17 | auVar3 << 0x18 | auVar18;
+      auVar19._4_4_ = (uint)local_43 << 8 | (uint)local_42 << 0x10;
+      auVar19._0_4_ = (uint)local_46 << 0x10 | (uint)local_47 << 8;
+      auVar19._12_4_ = (uint)local_3b << 8 | (uint)local_3a << 0x10;
+      auVar19._8_4_ = (uint)local_3e << 0x10 | (uint)local_3f << 8;
+      auVar20._9_3_ = 0;
+      auVar20[8] = local_40;
+      uVar12 = auVar17._0_4_;
+      auVar20._1_3_ = 0;
+      auVar20[0] = local_48;
+      auVar20[12] = local_3c;
+      auVar4._1_4_ = (uint)local_41 << 0x18;
+      auVar4[0] = local_45;
+      auVar4._5_4_ = (uint)local_3d << 0x18;
+      auVar4._9_4_ = (uint)local_39 << 0x18;
+      auVar4._13_3_ = 0;
+      auVar20[4] = local_44;
+      auVar20._5_3_ = 0;
+      auVar20._13_3_ = 0;
+      uVar9 = auVar17._4_4_;
+      uVar6 = auVar17._8_4_;
+      uVar8 = auVar17._12_4_;
+      local_88 = auVar19 | auVar4 << 0x18 | auVar20;
+      do {
+        uVar14 = uVar14 + 0x9e3779b9;
+        uVar13 = uVar14 >> 2;
+        uVar12 = uVar12 + ((uVar8 >> 5 ^ uVar9 * 4) + (uVar9 >> 3 ^ uVar8 << 4) ^
+                          (*(uint *)(local_88 + (ulong)(uVar13 & 3) * 4) ^ uVar8) + (uVar9 ^ uVar14)
+                          );
+        uVar9 = uVar9 + ((uVar12 >> 5 ^ uVar6 * 4) + (uVar6 >> 3 ^ uVar12 * 0x10) ^
+                        (*(uint *)(local_88 + (ulong)((uVar13 ^ 1) & 3) * 4) ^ uVar12) +
+                        (uVar14 ^ uVar6));
+        uVar6 = uVar6 + ((uVar9 >> 5 ^ uVar8 * 4) + (uVar8 >> 3 ^ uVar9 * 0x10) ^
+                        (*(uint *)(local_88 + (ulong)((uVar13 ^ 2) & 3) * 4) ^ uVar9) +
+                        (uVar14 ^ uVar8));
+        uVar8 = uVar8 + ((*(uint *)(local_88 + (ulong)(~uVar13 & 3) * 4) ^ uVar6) +
+                         (uVar14 ^ uVar12) ^
+                        (uVar6 >> 5 ^ uVar12 * 4) + (uVar12 >> 3 ^ uVar6 * 0x10));
+      } while (uVar14 != 0xbe1e08bb);
+      local_8c = (byte)(uVar6 >> 0x18);
+      local_90 = (byte)(uVar6 >> 0x10);
+      local_78 = (((((((ulong)(uVar9 >> 0x18) << 8 | (ulong)(uVar9 >> 0x10 & 0xff)) << 8 |
+                     (ulong)(uVar9 >> 8 & 0xff)) << 8 | (ulong)(uVar9 & 0xff)) << 8 |
+                   (ulong)(uVar12 >> 0x18)) << 8 | (ulong)(uVar12 >> 0x10 & 0xff)) << 8 |
+                 (ulong)(uVar12 >> 8 & 0xff)) << 8 | (ulong)(uVar12 & 0xff);
+      local_a8 = (byte)(uVar6 >> 8);
+      uStack_70 = (((((((ulong)(uVar8 >> 0x18) << 8 | (ulong)(uVar8 >> 0x10 & 0xff)) << 8 |
+                      (ulong)(uVar8 >> 8 & 0xff)) << 8 | (ulong)(uVar8 & 0xff)) << 8 |
+                    (ulong)local_8c) << 8 | (ulong)local_90) << 8 | (ulong)local_a8) << 8 |
+                  (ulong)(uVar6 & 0xff);
+      __printf_chk(1,"Ciphertext(hex): ");
+      puVar15 = &local_78;
+      do {
+        uVar2 = *(undefined *)puVar15;
+        puVar15 = (ulong *)((long)puVar15 + 1);
+        __printf_chk(1,&DAT_00102057,uVar2);
+      } while (puVar15 != &local_68);
+      __printf_chk(1,"\n");
+      iVar5 = memcmp(&local_78,&local_58,0x10);
+      pcVar11 = "True";
+      if (iVar5 != 0) {
+        pcVar11 = "False";
+      }
+      __printf_chk(1,"Match: %s\n",pcVar11);
+      bVar16 = iVar5 != 0;
+    }
+    else {
+LAB_001011fb:
+      __fprintf_chk(*(undefined8 *)PTR_stderr_00103ff8,1,
+                    "Bad input hex. Expecting 32 hex chars (16 bytes).\n");
+      bVar16 = true;
+    }
+  }
+  else {
+    __fprintf_chk(*(undefined8 *)PTR_stderr_00103ff8,1,"Usage: %s <32-hex-chars>\n",*param_2);
+    bVar16 = true;
+  }
+  if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
+    return bVar16;
+  }
+                    /* WARNING: Subroutine does not return */
+  __stack_chk_fail();
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/FUN_00101730_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Removing unreachable block (ram,0x00101743) */
+/* WARNING: Removing unreachable block (ram,0x0010174f) */
+
+void FUN_00101730(void)
+
+{
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/FUN_00101760_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Removing unreachable block (ram,0x00101784) */
+/* WARNING: Removing unreachable block (ram,0x00101790) */
+
+void FUN_00101760(void)
+
+{
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/FUN_001017f0_decompiled

@@ -0,0 +1,12 @@
+
+void FUN_001017f0(long param_1,ulong param_2)
+
+{
+  ulong local_18;
+  
+  for (local_18 = 0; local_18 < param_2; local_18 = local_18 + 1) {
+    *(undefined *)(local_18 + param_1) = (&DAT_00102010)[(uint)local_18 & 0xf];
+  }
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/_DT_FINI_decompiled

@@ -0,0 +1,7 @@
+
+void _DT_FINI(void)
+
+{
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/_DT_INIT_decompiled

@@ -0,0 +1,10 @@
+
+void _DT_INIT(void)
+
+{
+  if (PTR___gmon_start___00103fe0 != (undefined *)0x0) {
+    (*(code *)PTR___gmon_start___00103fe0)();
+  }
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/_FINI_0_decompiled

@@ -0,0 +1,15 @@
+
+void _FINI_0(void)
+
+{
+  if (DAT_00104010 == '\0') {
+    if (PTR___cxa_finalize_00103ff0 != (undefined *)0x0) {
+      __cxa_finalize(PTR_LOOP_00104008);
+    }
+    FUN_00101730();
+    DAT_00104010 = 1;
+    return;
+  }
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/_INIT_0_decompiled

@@ -0,0 +1,8 @@
+
+void _INIT_0(void)
+
+{
+  FUN_00101760();
+  return;
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/_ITM_deregisterTMCloneTable_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void _ITM_deregisterTMCloneTable(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/_ITM_registerTMCloneTable_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void _ITM_registerTMCloneTable(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/__cxa_finalize_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __cxa_finalize(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/__fprintf_chk_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __fprintf_chk(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/__gmon_start___decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __gmon_start__(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/__libc_start_main_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __libc_start_main(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/__printf_chk_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __printf_chk(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+

CREBench/XXTEA/public-hardcode_plain-O3/decompile/__stack_chk_fail_decompiled

@@ -0,0 +1,10 @@
+
+/* WARNING: Control flow encountered bad instruction data */
+
+void __stack_chk_fail(void)
+
+{
+                    /* WARNING: Bad instruction - Truncating control flow here */
+  halt_baddata();
+}
+