
freecell-solver-multi-thread-solve:     file format elf64-x86-64


Disassembly of section .init:

0000000000401000 <_init>:
  401000:	48 83 ec 08          	sub    $0x8,%rsp
  401004:	48 8b 05 ed 2f 01 00 	mov    0x12fed(%rip),%rax        # 413ff8 <__gmon_start__>
  40100b:	48 85 c0             	test   %rax,%rax
  40100e:	74 02                	je     401012 <_init+0x12>
  401010:	ff d0                	callq  *%rax
  401012:	48 83 c4 08          	add    $0x8,%rsp
  401016:	c3                   	retq   

Disassembly of section .plt:

0000000000401020 <.plt>:
  401020:	ff 35 e2 2f 01 00    	pushq  0x12fe2(%rip)        # 414008 <_GLOBAL_OFFSET_TABLE_+0x8>
  401026:	ff 25 e4 2f 01 00    	jmpq   *0x12fe4(%rip)        # 414010 <_GLOBAL_OFFSET_TABLE_+0x10>
  40102c:	0f 1f 40 00          	nopl   0x0(%rax)

0000000000401030 <printf@plt>:
  401030:	ff 25 e2 2f 01 00    	jmpq   *0x12fe2(%rip)        # 414018 <printf@GLIBC_2.2.5>
  401036:	68 00 00 00 00       	pushq  $0x0
  40103b:	e9 e0 ff ff ff       	jmpq   401020 <.plt>

0000000000401040 <strtoll@plt>:
  401040:	ff 25 da 2f 01 00    	jmpq   *0x12fda(%rip)        # 414020 <strtoll@GLIBC_2.2.5>
  401046:	68 01 00 00 00       	pushq  $0x1
  40104b:	e9 d0 ff ff ff       	jmpq   401020 <.plt>

0000000000401050 <free@plt>:
  401050:	ff 25 d2 2f 01 00    	jmpq   *0x12fd2(%rip)        # 414028 <free>
  401056:	68 02 00 00 00       	pushq  $0x2
  40105b:	e9 c0 ff ff ff       	jmpq   401020 <.plt>

0000000000401060 <strchr@plt>:
  401060:	ff 25 ca 2f 01 00    	jmpq   *0x12fca(%rip)        # 414030 <strchr@GLIBC_2.2.5>
  401066:	68 03 00 00 00       	pushq  $0x3
  40106b:	e9 b0 ff ff ff       	jmpq   401020 <.plt>

0000000000401070 <strlen@plt>:
  401070:	ff 25 c2 2f 01 00    	jmpq   *0x12fc2(%rip)        # 414038 <strlen@GLIBC_2.2.5>
  401076:	68 04 00 00 00       	pushq  $0x4
  40107b:	e9 a0 ff ff ff       	jmpq   401020 <.plt>

0000000000401080 <memcmp@plt>:
  401080:	ff 25 ba 2f 01 00    	jmpq   *0x12fba(%rip)        # 414040 <memcmp@GLIBC_2.2.5>
  401086:	68 05 00 00 00       	pushq  $0x5
  40108b:	e9 90 ff ff ff       	jmpq   401020 <.plt>

0000000000401090 <pthread_join@plt>:
  401090:	ff 25 b2 2f 01 00    	jmpq   *0x12fb2(%rip)        # 414048 <pthread_join@GLIBC_2.2.5>
  401096:	68 06 00 00 00       	pushq  $0x6
  40109b:	e9 80 ff ff ff       	jmpq   401020 <.plt>

00000000004010a0 <memset@plt>:
  4010a0:	ff 25 aa 2f 01 00    	jmpq   *0x12faa(%rip)        # 414050 <memset@GLIBC_2.2.5>
  4010a6:	68 07 00 00 00       	pushq  $0x7
  4010ab:	e9 70 ff ff ff       	jmpq   401020 <.plt>

00000000004010b0 <pthread_create@plt>:
  4010b0:	ff 25 a2 2f 01 00    	jmpq   *0x12fa2(%rip)        # 414058 <pthread_create@GLIBC_2.2.5>
  4010b6:	68 08 00 00 00       	pushq  $0x8
  4010bb:	e9 60 ff ff ff       	jmpq   401020 <.plt>

00000000004010c0 <pthread_mutex_unlock@plt>:
  4010c0:	ff 25 9a 2f 01 00    	jmpq   *0x12f9a(%rip)        # 414060 <pthread_mutex_unlock@GLIBC_2.2.5>
  4010c6:	68 09 00 00 00       	pushq  $0x9
  4010cb:	e9 50 ff ff ff       	jmpq   401020 <.plt>

00000000004010d0 <strtod@plt>:
  4010d0:	ff 25 92 2f 01 00    	jmpq   *0x12f92(%rip)        # 414068 <strtod@GLIBC_2.2.5>
  4010d6:	68 0a 00 00 00       	pushq  $0xa
  4010db:	e9 40 ff ff ff       	jmpq   401020 <.plt>

00000000004010e0 <memcpy@plt>:
  4010e0:	ff 25 8a 2f 01 00    	jmpq   *0x12f8a(%rip)        # 414070 <memcpy@GLIBC_2.14>
  4010e6:	68 0b 00 00 00       	pushq  $0xb
  4010eb:	e9 30 ff ff ff       	jmpq   401020 <.plt>

00000000004010f0 <malloc@plt>:
  4010f0:	ff 25 82 2f 01 00    	jmpq   *0x12f82(%rip)        # 414078 <malloc>
  4010f6:	68 0c 00 00 00       	pushq  $0xc
  4010fb:	e9 20 ff ff ff       	jmpq   401020 <.plt>

0000000000401100 <calloc@plt>:
  401100:	ff 25 7a 2f 01 00    	jmpq   *0x12f7a(%rip)        # 414080 <calloc>
  401106:	68 0d 00 00 00       	pushq  $0xd
  40110b:	e9 10 ff ff ff       	jmpq   401020 <.plt>

0000000000401110 <exit@plt>:
  401110:	ff 25 72 2f 01 00    	jmpq   *0x12f72(%rip)        # 414088 <exit@GLIBC_2.2.5>
  401116:	68 0e 00 00 00       	pushq  $0xe
  40111b:	e9 00 ff ff ff       	jmpq   401020 <.plt>

0000000000401120 <vfprintf@plt>:
  401120:	ff 25 6a 2f 01 00    	jmpq   *0x12f6a(%rip)        # 414090 <vfprintf@GLIBC_2.2.5>
  401126:	68 0f 00 00 00       	pushq  $0xf
  40112b:	e9 f0 fe ff ff       	jmpq   401020 <.plt>

0000000000401130 <strtol@plt>:
  401130:	ff 25 62 2f 01 00    	jmpq   *0x12f62(%rip)        # 414098 <strtol@GLIBC_2.2.5>
  401136:	68 10 00 00 00       	pushq  $0x10
  40113b:	e9 e0 fe ff ff       	jmpq   401020 <.plt>

0000000000401140 <fprintf@plt>:
  401140:	ff 25 5a 2f 01 00    	jmpq   *0x12f5a(%rip)        # 4140a0 <fprintf@GLIBC_2.2.5>
  401146:	68 11 00 00 00       	pushq  $0x11
  40114b:	e9 d0 fe ff ff       	jmpq   401020 <.plt>

0000000000401150 <pthread_mutex_lock@plt>:
  401150:	ff 25 52 2f 01 00    	jmpq   *0x12f52(%rip)        # 4140a8 <pthread_mutex_lock@GLIBC_2.2.5>
  401156:	68 12 00 00 00       	pushq  $0x12
  40115b:	e9 c0 fe ff ff       	jmpq   401020 <.plt>

0000000000401160 <gettimeofday@plt>:
  401160:	ff 25 4a 2f 01 00    	jmpq   *0x12f4a(%rip)        # 4140b0 <gettimeofday@GLIBC_2.2.5>
  401166:	68 13 00 00 00       	pushq  $0x13
  40116b:	e9 b0 fe ff ff       	jmpq   401020 <.plt>

0000000000401170 <realloc@plt>:
  401170:	ff 25 42 2f 01 00    	jmpq   *0x12f42(%rip)        # 4140b8 <realloc>
  401176:	68 14 00 00 00       	pushq  $0x14
  40117b:	e9 a0 fe ff ff       	jmpq   401020 <.plt>

Disassembly of section .text:

0000000000401180 <main>:

static inline int range_solvers_main(
    int argc, char *argv[], int arg, long long, long long, long long);
int main(int argc, char *argv[])
{
    if (argc < 4)
  401180:	83 ff 03             	cmp    $0x3,%edi
  401183:	0f 8e c9 02 00 00    	jle    401452 <main+0x2d2>
{
  401189:	55                   	push   %rbp

# ifdef __USE_ISOC99
__extension__ __extern_inline long long int
__NTH (atoll (const char *__nptr))
{
  return strtoll (__nptr, (char **) NULL, 10);
  40118a:	ba 0a 00 00 00       	mov    $0xa,%edx
  40118f:	48 89 e5             	mov    %rsp,%rbp
  401192:	41 57                	push   %r15
  401194:	41 56                	push   %r14
  401196:	41 55                	push   %r13
  401198:	41 89 fd             	mov    %edi,%r13d
  40119b:	41 54                	push   %r12
  40119d:	49 89 f4             	mov    %rsi,%r12
  4011a0:	53                   	push   %rbx
  4011a1:	48 83 ec 48          	sub    $0x48,%rsp
  4011a5:	48 8b 7e 08          	mov    0x8(%rsi),%rdi
  4011a9:	31 f6                	xor    %esi,%esi
  4011ab:	e8 90 fe ff ff       	callq  401040 <strtoll@plt>
  4011b0:	49 8b 7c 24 10       	mov    0x10(%r12),%rdi
  4011b5:	31 f6                	xor    %esi,%esi
  4011b7:	ba 0a 00 00 00       	mov    $0xa,%edx
  4011bc:	49 89 c6             	mov    %rax,%r14
  4011bf:	e8 7c fe ff ff       	callq  401040 <strtoll@plt>
  4011c4:	49 8b 7c 24 18       	mov    0x18(%r12),%rdi
  4011c9:	31 f6                	xor    %esi,%esi
  4011cb:	ba 0a 00 00 00       	mov    $0xa,%edx
  4011d0:	48 89 c3             	mov    %rax,%rbx
  4011d3:	e8 68 fe ff ff       	callq  401040 <strtoll@plt>
    int arg = 1;
    const long long next_board_num = atoll(argv[arg++]);
    const long long end_board = atoll(argv[arg++]);
    const long long stop_at = atoll(argv[arg++]);

    if (stop_at <= 0)
  4011d8:	48 85 c0             	test   %rax,%rax
  4011db:	0f 8e 3b 02 00 00    	jle    40141c <main+0x29c>
    int arg = par__arg;
#else
    arg = par__arg;
#endif
    next_board_num = par__next_board_num;
    past_end_board = 1 + par__end_board;
  4011e1:	48 83 c3 01          	add    $0x1,%rbx
    next_board_num_lock = initial_mutex_constant;
  4011e5:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4011e9:	48 c7 05 8c 2f 01 00 	movq   $0x0,0x12f8c(%rip)        # 414180 <next_board_num_lock+0x20>
  4011f0:	00 00 00 00 
  4011f4:	c5 f8 29 05 64 2f 01 	vmovaps %xmm0,0x12f64(%rip)        # 414160 <next_board_num_lock>
  4011fb:	00 
  4011fc:	c5 f8 29 05 6c 2f 01 	vmovaps %xmm0,0x12f6c(%rip)        # 414170 <next_board_num_lock+0x10>
  401203:	00 
    total_num_iters_lock = initial_mutex_constant;
  401204:	c5 f8 29 05 14 2f 01 	vmovaps %xmm0,0x12f14(%rip)        # 414120 <total_num_iters_lock>
  40120b:	00 
  40120c:	c5 f8 29 05 1c 2f 01 	vmovaps %xmm0,0x12f1c(%rip)        # 414130 <total_num_iters_lock+0x10>
  401213:	00 
  401214:	48 c7 05 21 2f 01 00 	movq   $0x0,0x12f21(%rip)        # 414140 <total_num_iters_lock+0x20>
  40121b:	00 00 00 00 
    next_board_num = par__next_board_num;
  40121f:	4c 89 35 2a 2f 01 00 	mov    %r14,0x12f2a(%rip)        # 414150 <next_board_num>
    past_end_board = 1 + par__end_board;
  401226:	48 89 1d 1b 2f 01 00 	mov    %rbx,0x12f1b(%rip)        # 414148 <past_end_board>
    stop_at = par__stop_at;
  40122d:	48 89 05 cc 2e 01 00 	mov    %rax,0x12ecc(%rip)        # 414100 <stop_at>

    size_t num_workers = 3;
    for (; arg < argc; ++arg)
  401234:	41 83 fd 04          	cmp    $0x4,%r13d
  401238:	0f 84 a8 01 00 00    	je     4013e6 <main+0x266>
    int arg = par__arg;
  40123e:	bb 04 00 00 00       	mov    $0x4,%ebx
    size_t num_workers = 3;
  401243:	41 be 03 00 00 00    	mov    $0x3,%r14d
  401249:	41 bf 7e f1 40 00    	mov    $0x40f17e,%r15d
  40124f:	eb 43                	jmp    401294 <main+0x114>
  401251:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401258:	00 00 00 00 
  40125c:	0f 1f 40 00          	nopl   0x0(%rax)
static const char *try_argv_param(
    const int argc, char **const argv, int *const arg, const char *const flag)
{
    if (!strcmp(argv[*arg], flag))
    {
        if (++(*arg) == argc)
  401260:	83 c3 01             	add    $0x1,%ebx
  401263:	41 39 dd             	cmp    %ebx,%r13d
  401266:	0f 84 c6 01 00 00    	je     401432 <main+0x2b2>
        {
            fc_solve_err("%s came without an argument!\n", flag);
        }
        return argv[*arg];
  40126c:	4b 8b 44 04 08       	mov    0x8(%r12,%r8,1),%rax
    {
        const char *param;
        if ((param = TRY_P("--num-workers")))
  401271:	48 85 c0             	test   %rax,%rax
  401274:	74 44                	je     4012ba <main+0x13a>
  return strtol (__nptr, (char **) NULL, 10);
  401276:	ba 0a 00 00 00       	mov    $0xa,%edx
  40127b:	31 f6                	xor    %esi,%esi
  40127d:	48 89 c7             	mov    %rax,%rdi
  401280:	e8 ab fe ff ff       	callq  401130 <strtol@plt>
    for (; arg < argc; ++arg)
  401285:	83 c3 01             	add    $0x1,%ebx
  401288:	49 89 c6             	mov    %rax,%r14
  40128b:	41 39 dd             	cmp    %ebx,%r13d
  40128e:	0f 8e 7c 00 00 00    	jle    401310 <main+0x190>
    if (!strcmp(argv[*arg], flag))
  401294:	48 63 c3             	movslq %ebx,%rax
  401297:	b9 0e 00 00 00       	mov    $0xe,%ecx
  40129c:	4c 89 ff             	mov    %r15,%rdi
  40129f:	4c 8d 04 c5 00 00 00 	lea    0x0(,%rax,8),%r8
  4012a6:	00 
  4012a7:	49 8b 04 c4          	mov    (%r12,%rax,8),%rax
  4012ab:	48 89 c6             	mov    %rax,%rsi
  4012ae:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  4012b0:	0f 97 c2             	seta   %dl
  4012b3:	80 da 00             	sbb    $0x0,%dl
  4012b6:	84 d2                	test   %dl,%dl
  4012b8:	74 a6                	je     401260 <main+0xe0>
  4012ba:	48 89 c6             	mov    %rax,%rsi
  4012bd:	bf aa f1 40 00       	mov    $0x40f1aa,%edi
  4012c2:	b9 0e 00 00 00       	mov    $0xe,%ecx
  4012c7:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  4012c9:	0f 97 c0             	seta   %al
  4012cc:	1c 00                	sbb    $0x0,%al
  4012ce:	84 c0                	test   %al,%al
  4012d0:	75 3e                	jne    401310 <main+0x190>
        if (++(*arg) == argc)
  4012d2:	83 c3 01             	add    $0x1,%ebx
  4012d5:	41 39 dd             	cmp    %ebx,%r13d
  4012d8:	0f 84 65 01 00 00    	je     401443 <main+0x2c3>
        return argv[*arg];
  4012de:	48 63 c3             	movslq %ebx,%rax
  4012e1:	49 8b 3c c4          	mov    (%r12,%rax,8),%rdi
        {
            num_workers = (size_t)atol(param);
        }
        else if ((param = TRY_P("--worker-step")))
  4012e5:	48 85 ff             	test   %rdi,%rdi
  4012e8:	74 26                	je     401310 <main+0x190>
  return strtoll (__nptr, (char **) NULL, 10);
  4012ea:	ba 0a 00 00 00       	mov    $0xa,%edx
  4012ef:	31 f6                	xor    %esi,%esi
    for (; arg < argc; ++arg)
  4012f1:	83 c3 01             	add    $0x1,%ebx
  4012f4:	e8 47 fd ff ff       	callq  401040 <strtoll@plt>
        {
            board_num_step = atoll(param);
  4012f9:	48 89 05 d0 2d 01 00 	mov    %rax,0x12dd0(%rip)        # 4140d0 <board_num_step>
    for (; arg < argc; ++arg)
  401300:	41 39 dd             	cmp    %ebx,%r13d
  401303:	7f 8f                	jg     401294 <main+0x114>
  401305:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40130c:	00 00 00 00 
#endif

static inline fcs_portable_time fcs_get_time(void)
{
    fcs_portable_time ret;
    FCS_GET_TIME(ret);
  401310:	48 8d 45 b0          	lea    -0x50(%rbp),%rax
    fc_solve_print_started_at();
#ifndef FCS_USE_PRECOMPILED_CMD_LINE_THEME
    context_argc = argc;
    context_argv = argv;
#endif
    pthread_t workers[num_workers];
  401314:	49 89 e5             	mov    %rsp,%r13
  401317:	48 8d 70 10          	lea    0x10(%rax),%rsi
  40131b:	48 89 c7             	mov    %rax,%rdi
  40131e:	e8 3d fe ff ff       	callq  401160 <gettimeofday@plt>
}

static inline void fc_solve_print_started_at(void)
{
    const_AUTO(mytime, fcs_get_time());
    printf("Started at " FCS_T_FMT "\n", FCS_TIME_GET_SEC(mytime),
  401323:	48 8b 55 b8          	mov    -0x48(%rbp),%rdx
  401327:	bf b8 f1 40 00       	mov    $0x40f1b8,%edi
  40132c:	31 c0                	xor    %eax,%eax
  40132e:	48 8b 75 b0          	mov    -0x50(%rbp),%rsi
  401332:	e8 f9 fc ff ff       	callq  401030 <printf@plt>
  401337:	4a 8d 04 f5 0f 00 00 	lea    0xf(,%r14,8),%rax
  40133e:	00 
  40133f:	48 83 e0 f0          	and    $0xfffffffffffffff0,%rax
  401343:	48 29 c4             	sub    %rax,%rsp
  401346:	49 89 e4             	mov    %rsp,%r12
    for (size_t idx = 0; idx < num_workers; ++idx)
  401349:	4d 85 f6             	test   %r14,%r14
  40134c:	74 56                	je     4013a4 <main+0x224>
  40134e:	4d 89 e7             	mov    %r12,%r15
    pthread_t workers[num_workers];
  401351:	31 db                	xor    %ebx,%ebx
  401353:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40135a:	00 00 00 00 
  40135e:	66 90                	xchg   %ax,%ax
    {
        const int check =
            pthread_create(&workers[idx], NULL, worker_thread, NULL);
  401360:	31 c9                	xor    %ecx,%ecx
  401362:	31 f6                	xor    %esi,%esi
  401364:	ba d0 d8 40 00       	mov    $0x40d8d0,%edx
  401369:	4c 89 ff             	mov    %r15,%rdi
  40136c:	e8 3f fd ff ff       	callq  4010b0 <pthread_create@plt>
        if (check)
  401371:	85 c0                	test   %eax,%eax
  401373:	0f 85 a8 00 00 00    	jne    401421 <main+0x2a1>
    for (size_t idx = 0; idx < num_workers; ++idx)
  401379:	48 83 c3 01          	add    $0x1,%rbx
  40137d:	49 83 c7 08          	add    $0x8,%r15
  401381:	4c 39 f3             	cmp    %r14,%rbx
  401384:	72 da                	jb     401360 <main+0x1e0>
                (unsigned long)idx, check);
        }
    }

    // Wait for all threads to finish.
    for (size_t idx = 0; idx < num_workers; ++idx)
  401386:	31 db                	xor    %ebx,%ebx
  401388:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40138f:	00 
    {
        pthread_join(workers[idx], NULL);
  401390:	49 8b 3c dc          	mov    (%r12,%rbx,8),%rdi
  401394:	31 f6                	xor    %esi,%esi
    for (size_t idx = 0; idx < num_workers; ++idx)
  401396:	48 83 c3 01          	add    $0x1,%rbx
        pthread_join(workers[idx], NULL);
  40139a:	e8 f1 fc ff ff       	callq  401090 <pthread_join@plt>
    for (size_t idx = 0; idx < num_workers; ++idx)
  40139f:	4c 39 f3             	cmp    %r14,%rbx
  4013a2:	72 ec                	jb     401390 <main+0x210>
    FCS_GET_TIME(ret);
  4013a4:	48 8d 45 90          	lea    -0x70(%rbp),%rax
    }
    fc_solve_print_finished(total_num_iters);
  4013a8:	48 8b 1d 59 2d 01 00 	mov    0x12d59(%rip),%rbx        # 414108 <total_num_iters>
  4013af:	48 8d 70 10          	lea    0x10(%rax),%rsi
  4013b3:	48 89 c7             	mov    %rax,%rdi
  4013b6:	e8 a5 fd ff ff       	callq  401160 <gettimeofday@plt>
}

static inline void fc_solve_print_finished(const long long total_num_iters)
{
    const_AUTO(mytime, fcs_get_time());
    printf(("Finished at " FCS_T_FMT " (total_num_iters=" FCS_LL_FMT ")\n"),
  4013bb:	48 8b 55 98          	mov    -0x68(%rbp),%rdx
  4013bf:	bf 98 14 41 00       	mov    $0x411498,%edi
  4013c4:	31 c0                	xor    %eax,%eax
  4013c6:	48 8b 75 90          	mov    -0x70(%rbp),%rsi
  4013ca:	48 89 d9             	mov    %rbx,%rcx
  4013cd:	e8 5e fc ff ff       	callq  401030 <printf@plt>
        help_err("print_step (the third argument) must be greater than 0.\n");
#else
        return -1;
#endif
    }
    return range_solvers_main(
  4013d2:	31 c0                	xor    %eax,%eax
  4013d4:	4c 89 ec             	mov    %r13,%rsp
        argc, argv, arg, next_board_num, end_board, stop_at);
}
  4013d7:	48 8d 65 d8          	lea    -0x28(%rbp),%rsp
  4013db:	5b                   	pop    %rbx
  4013dc:	41 5c                	pop    %r12
  4013de:	41 5d                	pop    %r13
  4013e0:	41 5e                	pop    %r14
  4013e2:	41 5f                	pop    %r15
  4013e4:	5d                   	pop    %rbp
  4013e5:	c3                   	retq   
    FCS_GET_TIME(ret);
  4013e6:	48 8d 45 b0          	lea    -0x50(%rbp),%rax
    pthread_t workers[num_workers];
  4013ea:	49 89 e5             	mov    %rsp,%r13
    size_t num_workers = 3;
  4013ed:	41 be 03 00 00 00    	mov    $0x3,%r14d
  4013f3:	48 8d 70 10          	lea    0x10(%rax),%rsi
  4013f7:	48 89 c7             	mov    %rax,%rdi
  4013fa:	e8 61 fd ff ff       	callq  401160 <gettimeofday@plt>
    printf("Started at " FCS_T_FMT "\n", FCS_TIME_GET_SEC(mytime),
  4013ff:	48 8b 55 b8          	mov    -0x48(%rbp),%rdx
  401403:	bf b8 f1 40 00       	mov    $0x40f1b8,%edi
  401408:	31 c0                	xor    %eax,%eax
  40140a:	48 8b 75 b0          	mov    -0x50(%rbp),%rsi
    pthread_t workers[num_workers];
  40140e:	4c 8d 65 b0          	lea    -0x50(%rbp),%r12
  401412:	e8 19 fc ff ff       	callq  401030 <printf@plt>
  401417:	e9 32 ff ff ff       	jmpq   40134e <main+0x1ce>
        return -1;
  40141c:	83 c8 ff             	or     $0xffffffff,%eax
  40141f:	eb b6                	jmp    4013d7 <main+0x257>
            fc_solve_err(
  401421:	89 c2                	mov    %eax,%edx
  401423:	48 89 de             	mov    %rbx,%rsi
  401426:	bf 58 14 41 00       	mov    $0x411458,%edi
  40142b:	31 c0                	xor    %eax,%eax
  40142d:	e8 de d7 00 00       	callq  40ec10 <fc_solve_err>
            fc_solve_err("%s came without an argument!\n", flag);
  401432:	be 7e f1 40 00       	mov    $0x40f17e,%esi
  401437:	bf 8c f1 40 00       	mov    $0x40f18c,%edi
  40143c:	31 c0                	xor    %eax,%eax
  40143e:	e8 cd d7 00 00       	callq  40ec10 <fc_solve_err>
  401443:	be aa f1 40 00       	mov    $0x40f1aa,%esi
  401448:	bf 8c f1 40 00       	mov    $0x40f18c,%edi
  40144d:	e8 be d7 00 00       	callq  40ec10 <fc_solve_err>
  401452:	83 c8 ff             	or     $0xffffffff,%eax
}
  401455:	c3                   	retq   
  401456:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40145d:	00 00 00 

0000000000401460 <_start>:
  401460:	31 ed                	xor    %ebp,%ebp
  401462:	49 89 d1             	mov    %rdx,%r9
  401465:	5e                   	pop    %rsi
  401466:	48 89 e2             	mov    %rsp,%rdx
  401469:	48 83 e4 f0          	and    $0xfffffffffffffff0,%rsp
  40146d:	50                   	push   %rax
  40146e:	54                   	push   %rsp
  40146f:	49 c7 c0 20 ed 40 00 	mov    $0x40ed20,%r8
  401476:	48 c7 c1 c0 ec 40 00 	mov    $0x40ecc0,%rcx
  40147d:	48 c7 c7 80 11 40 00 	mov    $0x401180,%rdi
  401484:	ff 15 66 2b 01 00    	callq  *0x12b66(%rip)        # 413ff0 <__libc_start_main@GLIBC_2.2.5>
  40148a:	f4                   	hlt    
  40148b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

0000000000401490 <deregister_tm_clones>:
  401490:	b8 d8 40 41 00       	mov    $0x4140d8,%eax
  401495:	48 3d d8 40 41 00    	cmp    $0x4140d8,%rax
  40149b:	74 13                	je     4014b0 <deregister_tm_clones+0x20>
  40149d:	b8 00 00 00 00       	mov    $0x0,%eax
  4014a2:	48 85 c0             	test   %rax,%rax
  4014a5:	74 09                	je     4014b0 <deregister_tm_clones+0x20>
  4014a7:	bf d8 40 41 00       	mov    $0x4140d8,%edi
  4014ac:	ff e0                	jmpq   *%rax
  4014ae:	66 90                	xchg   %ax,%ax
  4014b0:	c3                   	retq   
  4014b1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4014b8:	00 00 00 00 
  4014bc:	0f 1f 40 00          	nopl   0x0(%rax)

00000000004014c0 <register_tm_clones>:
  4014c0:	be d8 40 41 00       	mov    $0x4140d8,%esi
  4014c5:	48 81 ee d8 40 41 00 	sub    $0x4140d8,%rsi
  4014cc:	48 c1 fe 03          	sar    $0x3,%rsi
  4014d0:	48 89 f0             	mov    %rsi,%rax
  4014d3:	48 c1 e8 3f          	shr    $0x3f,%rax
  4014d7:	48 01 c6             	add    %rax,%rsi
  4014da:	48 d1 fe             	sar    %rsi
  4014dd:	74 11                	je     4014f0 <register_tm_clones+0x30>
  4014df:	b8 00 00 00 00       	mov    $0x0,%eax
  4014e4:	48 85 c0             	test   %rax,%rax
  4014e7:	74 07                	je     4014f0 <register_tm_clones+0x30>
  4014e9:	bf d8 40 41 00       	mov    $0x4140d8,%edi
  4014ee:	ff e0                	jmpq   *%rax
  4014f0:	c3                   	retq   
  4014f1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4014f8:	00 00 00 00 
  4014fc:	0f 1f 40 00          	nopl   0x0(%rax)

0000000000401500 <__do_global_dtors_aux>:
  401500:	80 3d e1 2b 01 00 00 	cmpb   $0x0,0x12be1(%rip)        # 4140e8 <completed.7983>
  401507:	75 17                	jne    401520 <__do_global_dtors_aux+0x20>
  401509:	55                   	push   %rbp
  40150a:	48 89 e5             	mov    %rsp,%rbp
  40150d:	e8 7e ff ff ff       	callq  401490 <deregister_tm_clones>
  401512:	c6 05 cf 2b 01 00 01 	movb   $0x1,0x12bcf(%rip)        # 4140e8 <completed.7983>
  401519:	5d                   	pop    %rbp
  40151a:	c3                   	retq   
  40151b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  401520:	c3                   	retq   
  401521:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401528:	00 00 00 00 
  40152c:	0f 1f 40 00          	nopl   0x0(%rax)

0000000000401530 <frame_dummy>:
  401530:	eb 8e                	jmp    4014c0 <register_tm_clones>
  401532:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  401539:	00 00 00 
  40153c:	0f 1f 40 00          	nopl   0x0(%rax)

0000000000401540 <fc_solve_canonize_state>:
#define GET_FREECELL(c) (fcs_freecell_card(*state_key, (c)))
#endif

void fc_solve_canonize_state(
    fcs_state *const ptr_state_key FREECELLS_AND_STACKS_ARGS())
{
  401540:	55                   	push   %rbp
#define state_key (ptr_state_key)
    /* Insertion-sort the columns */

    for (size_t b = 1; b < STACKS_NUM__VAL; b++)
  401541:	bd 01 00 00 00       	mov    $0x1,%ebp
{
  401546:	53                   	push   %rbx
  401547:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40154e:	00 00 
  401550:	49 89 ea             	mov    %rbp,%r10
    {
        size_t c = b;
        while ((c > 0) && ((STACK_COMPARE(GET_STACK(c), GET_STACK(c - 1))) < 0))
  401553:	49 83 ea 01          	sub    $0x1,%r10
  401557:	4e 8b 04 d7          	mov    (%rdi,%r10,8),%r8
  40155b:	4e 8b 4c d7 08       	mov    0x8(%rdi,%r10,8),%r9
{
    const fcs_card *const s1 = (const fcs_card *const)v_s1;
    const fcs_card *const s2 = (const fcs_card *const)v_s2;

    {
        const int min_len = min(s1[0], s2[0]);
  401560:	45 0f b6 18          	movzbl (%r8),%r11d
  401564:	41 0f be 19          	movsbl (%r9),%ebx
  401568:	41 0f be f3          	movsbl %r11b,%esi
  40156c:	44 38 db             	cmp    %r11b,%bl
  40156f:	0f 4e f3             	cmovle %ebx,%esi
        for (int a = 1; a <= min_len; a++)
  401572:	85 f6                	test   %esi,%esi
  401574:	7e 34                	jle    4015aa <fc_solve_canonize_state+0x6a>
        {
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
  401576:	41 0f be 51 01       	movsbl 0x1(%r9),%edx
  40157b:	41 0f be 40 01       	movsbl 0x1(%r8),%eax
            if (ret != 0)
  401580:	29 c2                	sub    %eax,%edx
  401582:	0f 85 b8 00 00 00    	jne    401640 <fc_solve_canonize_state+0x100>
  401588:	b8 02 00 00 00       	mov    $0x2,%eax
  40158d:	eb 17                	jmp    4015a6 <fc_solve_canonize_state+0x66>
  40158f:	90                   	nop
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
  401590:	41 0f be 14 01       	movsbl (%r9,%rax,1),%edx
  401595:	41 0f be 0c 00       	movsbl (%r8,%rax,1),%ecx
            if (ret != 0)
  40159a:	48 83 c0 01          	add    $0x1,%rax
  40159e:	29 ca                	sub    %ecx,%edx
  4015a0:	0f 85 9a 00 00 00    	jne    401640 <fc_solve_canonize_state+0x100>
        for (int a = 1; a <= min_len; a++)
  4015a6:	39 c6                	cmp    %eax,%esi
  4015a8:	7d e6                	jge    401590 <fc_solve_canonize_state+0x50>
     * comparison is to maintain correspondence with
     * fcs_stack_compare_for_stack_sort, and with the one card comparison
     * of the other state representation mechanisms.
     * */
    /* For some reason this code is faster than s1[0]-s2[0] */
    if (s1[0] < s2[0])
  4015aa:	44 38 db             	cmp    %r11b,%bl
  4015ad:	0f 8c 95 00 00 00    	jl     401648 <fc_solve_canonize_state+0x108>
    for (size_t b = 1; b < STACKS_NUM__VAL; b++)
  4015b3:	48 83 c5 01          	add    $0x1,%rbp
  4015b7:	48 83 fd 08          	cmp    $0x8,%rbp
  4015bb:	75 93                	jne    401550 <fc_solve_canonize_state+0x10>
  4015bd:	0f b7 57 40          	movzwl 0x40(%rdi),%edx
    // Insertion-sort the freecells
    for (size_t b = 1; b < FREECELLS_NUM__VAL; b++)
    {
        size_t c = b;

        while ((c > 0) && ((fc_solve_card_compare(
  4015c1:	0f be 47 41          	movsbl 0x41(%rdi),%eax
  4015c5:	0f be 4f 40          	movsbl 0x40(%rdi),%ecx
  4015c9:	66 c1 c2 08          	rol    $0x8,%dx
  4015cd:	39 c8                	cmp    %ecx,%eax
  4015cf:	79 0a                	jns    4015db <fc_solve_canonize_state+0x9b>
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
        {
            const fcs_card temp_freecell = GET_FREECELL(c);
            GET_FREECELL(c) = GET_FREECELL(c - 1);
            GET_FREECELL(c - 1) = temp_freecell;
  4015d1:	0f b6 c6             	movzbl %dh,%eax
  4015d4:	66 89 57 40          	mov    %dx,0x40(%rdi)

            --c;
  4015d8:	0f be c0             	movsbl %al,%eax
  4015db:	0f b7 57 41          	movzwl 0x41(%rdi),%edx
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  4015df:	0f be 4f 42          	movsbl 0x42(%rdi),%ecx
    return (c1) - (c2);
  4015e3:	66 c1 c2 08          	rol    $0x8,%dx
        while ((c > 0) && ((fc_solve_card_compare(
  4015e7:	39 c1                	cmp    %eax,%ecx
  4015e9:	79 12                	jns    4015fd <fc_solve_canonize_state+0xbd>
            GET_FREECELL(c - 1) = temp_freecell;
  4015eb:	66 89 57 41          	mov    %dx,0x41(%rdi)
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  4015ef:	0f be 57 40          	movsbl 0x40(%rdi),%edx
        while ((c > 0) && ((fc_solve_card_compare(
  4015f3:	39 d1                	cmp    %edx,%ecx
  4015f5:	79 06                	jns    4015fd <fc_solve_canonize_state+0xbd>
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  4015f7:	88 57 41             	mov    %dl,0x41(%rdi)
            GET_FREECELL(c - 1) = temp_freecell;
  4015fa:	88 4f 40             	mov    %cl,0x40(%rdi)
            --c;
  4015fd:	0f b7 47 42          	movzwl 0x42(%rdi),%eax
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  401601:	0f be 57 43          	movsbl 0x43(%rdi),%edx
        while ((c > 0) && ((fc_solve_card_compare(
  401605:	0f be 77 42          	movsbl 0x42(%rdi),%esi
  401609:	66 c1 c0 08          	rol    $0x8,%ax
  40160d:	39 f2                	cmp    %esi,%edx
  40160f:	79 22                	jns    401633 <fc_solve_canonize_state+0xf3>
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  401611:	0f be 77 41          	movsbl 0x41(%rdi),%esi
            GET_FREECELL(c - 1) = temp_freecell;
  401615:	66 89 47 42          	mov    %ax,0x42(%rdi)
        while ((c > 0) && ((fc_solve_card_compare(
  401619:	39 f2                	cmp    %esi,%edx
  40161b:	79 16                	jns    401633 <fc_solve_canonize_state+0xf3>
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  40161d:	40 88 77 42          	mov    %sil,0x42(%rdi)
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  401621:	0f be 77 40          	movsbl 0x40(%rdi),%esi
            GET_FREECELL(c - 1) = temp_freecell;
  401625:	88 57 41             	mov    %dl,0x41(%rdi)
        while ((c > 0) && ((fc_solve_card_compare(
  401628:	39 f2                	cmp    %esi,%edx
  40162a:	79 07                	jns    401633 <fc_solve_canonize_state+0xf3>
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  40162c:	40 88 77 41          	mov    %sil,0x41(%rdi)
            GET_FREECELL(c - 1) = temp_freecell;
  401630:	88 57 40             	mov    %dl,0x40(%rdi)
        }
    }
#endif
}
  401633:	5b                   	pop    %rbx
  401634:	5d                   	pop    %rbp
  401635:	c3                   	retq   
  401636:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40163d:	00 00 00 
        while ((c > 0) && ((STACK_COMPARE(GET_STACK(c), GET_STACK(c - 1))) < 0))
  401640:	85 d2                	test   %edx,%edx
  401642:	0f 89 6b ff ff ff    	jns    4015b3 <fc_solve_canonize_state+0x73>
                COPY_STACK(GET_STACK(c), GET_STACK(c - 1));
  401648:	4e 89 44 d7 08       	mov    %r8,0x8(%rdi,%r10,8)
                COPY_STACK(GET_STACK(c - 1), temp_stack);
  40164d:	4e 89 0c d7          	mov    %r9,(%rdi,%r10,8)
        while ((c > 0) && ((STACK_COMPARE(GET_STACK(c), GET_STACK(c - 1))) < 0))
  401651:	4d 85 d2             	test   %r10,%r10
  401654:	0f 85 f9 fe ff ff    	jne    401553 <fc_solve_canonize_state+0x13>
  40165a:	e9 54 ff ff ff       	jmpq   4015b3 <fc_solve_canonize_state+0x73>
  40165f:	90                   	nop

0000000000401660 <fc_solve_new_soft_thread>:
    fc_solve_foreach_soft_thread(
        instance, FOREACH_SOFT_THREAD_CLEAN_SOFT_DFS, NULL);
}

fcs_soft_thread *fc_solve_new_soft_thread(fcs_hard_thread *const hard_thread)
{
  401660:	41 57                	push   %r15
  401662:	41 56                	push   %r14
  401664:	41 55                	push   %r13
  401666:	41 54                	push   %r12
  401668:	55                   	push   %rbp
  401669:	53                   	push   %rbx
  40166a:	48 83 ec 18          	sub    $0x18,%rsp
    if (HT_INSTANCE(hard_thread)->next_soft_thread_id == MAX_NUM_SCANS)
  40166e:	83 bf 48 05 00 00 20 	cmpl   $0x20,0x548(%rdi)
  401675:	0f 84 c5 01 00 00    	je     401840 <fc_solve_new_soft_thread+0x1e0>
    {
        return NULL;
    }

    HT_FIELD(hard_thread, soft_threads) =
        SREALLOC(HT_FIELD(hard_thread, soft_threads),
  40167b:	48 8b 87 20 05 00 00 	mov    0x520(%rdi),%rax
  401682:	48 89 fd             	mov    %rdi,%rbp
  401685:	48 8b bf c0 00 00 00 	mov    0xc0(%rdi),%rdi
  40168c:	48 8d 70 01          	lea    0x1(%rax),%rsi
  401690:	48 69 f6 f8 01 00 00 	imul   $0x1f8,%rsi,%rsi
  401697:	e8 d4 fa ff ff       	callq  401170 <realloc@plt>

    fcs_soft_thread *ret;

    fc_solve_init_soft_thread(hard_thread,
        (ret = &(HT_FIELD(hard_thread,
             soft_threads)[HT_FIELD(hard_thread, num_soft_threads)++])));
  40169c:	48 8b 95 20 05 00 00 	mov    0x520(%rbp),%rdx
                    SMALLOC1(soft_thread->by_depth_moves_order.by_depth_moves),
  4016a3:	bf 18 00 00 00       	mov    $0x18,%edi
        .id = (HT_INSTANCE(hard_thread)->next_soft_thread_id)++,
  4016a8:	44 8b ad 48 05 00 00 	mov    0x548(%rbp),%r13d
    HT_FIELD(hard_thread, soft_threads) =
  4016af:	48 89 85 c0 00 00 00 	mov    %rax,0xc0(%rbp)
             soft_threads)[HT_FIELD(hard_thread, num_soft_threads)++])));
  4016b6:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  4016ba:	48 69 d2 f8 01 00 00 	imul   $0x1f8,%rdx,%rdx
  4016c1:	48 89 8d 20 05 00 00 	mov    %rcx,0x520(%rbp)
        (ret = &(HT_FIELD(hard_thread,
  4016c8:	48 8d 1c 10          	lea    (%rax,%rdx,1),%rbx
        .id = (HT_INSTANCE(hard_thread)->next_soft_thread_id)++,
  4016cc:	41 8d 45 01          	lea    0x1(%r13),%eax
  4016d0:	89 85 48 05 00 00    	mov    %eax,0x548(%rbp)
                    SMALLOC1(soft_thread->by_depth_moves_order.by_depth_moves),
  4016d6:	e8 15 fa ff ff       	callq  4010f0 <malloc@plt>
    *soft_thread = (fcs_soft_thread){
  4016db:	b9 3f 00 00 00       	mov    $0x3f,%ecx
  4016e0:	48 89 df             	mov    %rbx,%rdi
                    SMALLOC1(soft_thread->by_depth_moves_order.by_depth_moves),
  4016e3:	49 89 c4             	mov    %rax,%r12
    *soft_thread = (fcs_soft_thread){
  4016e6:	31 c0                	xor    %eax,%eax
  4016e8:	f3 48 ab             	rep stos %rax,%es:(%rdi)
  4016eb:	48 8b 05 d6 fd 00 00 	mov    0xfdd6(%rip),%rax        # 4114c8 <fc_solve_is_parent_buf+0xf08>
  4016f2:	44 89 6b 08          	mov    %r13d,0x8(%rbx)
  4016f6:	48 c7 43 10 01 00 00 	movq   $0x1,0x10(%rbx)
  4016fd:	00 
  4016fe:	48 89 2b             	mov    %rbp,(%rbx)
            .moves_order = moves_order_dup(
  401701:	4c 8b bd 38 05 00 00 	mov    0x538(%rbp),%r15
    *soft_thread = (fcs_soft_thread){
  401708:	48 c7 83 e8 01 00 00 	movq   $0x32,0x1e8(%rbx)
  40170f:	32 00 00 00 
            .moves_order = moves_order_dup(
  401713:	4c 8b ad 30 05 00 00 	mov    0x530(%rbp),%r13
    *soft_thread = (fcs_soft_thread){
  40171a:	48 89 83 a8 01 00 00 	mov    %rax,0x1a8(%rbx)
  401721:	48 8b 05 a8 fd 00 00 	mov    0xfda8(%rip),%rax        # 4114d0 <fc_solve_is_parent_buf+0xf10>
  401728:	4c 89 63 18          	mov    %r12,0x18(%rbx)
  40172c:	c7 43 48 18 00 00 00 	movl   $0x18,0x48(%rbx)
{
    const_SLOT(num, orig);
    fcs_moves_order ret = (fcs_moves_order){.num = num,
        .groups = memdup(orig->groups,
            sizeof(orig->groups[0]) *
                ((num & (~(MOVES_GROW_BY - 1))) + MOVES_GROW_BY))};
  401733:	4c 89 ed             	mov    %r13,%rbp
  401736:	48 83 e5 f0          	and    $0xfffffffffffffff0,%rbp
  40173a:	48 89 83 b8 01 00 00 	mov    %rax,0x1b8(%rbx)
  401741:	48 8b 05 90 fd 00 00 	mov    0xfd90(%rip),%rax        # 4114d8 <fc_solve_is_parent_buf+0xf18>
        .groups = memdup(orig->groups,
  401748:	48 69 ed e8 00 00 00 	imul   $0xe8,%rbp,%rbp
  40174f:	48 89 83 c8 01 00 00 	mov    %rax,0x1c8(%rbx)
  401756:	48 81 c5 80 0e 00 00 	add    $0xe80,%rbp
    void *const dest = malloc(my_size);
  40175d:	48 89 ef             	mov    %rbp,%rdi
  401760:	e8 8b f9 ff ff       	callq  4010f0 <malloc@plt>
  401765:	49 89 c6             	mov    %rax,%r14
    if (dest == NULL)
  401768:	48 85 c0             	test   %rax,%rax
  40176b:	74 0e                	je     40177b <fc_solve_new_soft_thread+0x11b>
    memcpy(dest, src, my_size);
  40176d:	48 89 ea             	mov    %rbp,%rdx
  401770:	4c 89 fe             	mov    %r15,%rsi
  401773:	48 89 c7             	mov    %rax,%rdi
  401776:	e8 65 f9 ff ff       	callq  4010e0 <memcpy@plt>

    for (size_t i = 0; i < num; ++i)
  40177b:	4d 85 ed             	test   %r13,%r13
  40177e:	74 5e                	je     4017de <fc_solve_new_soft_thread+0x17e>
  401780:	4d 69 fd e8 00 00 00 	imul   $0xe8,%r13,%r15
  401787:	4c 89 f5             	mov    %r14,%rbp
  40178a:	4d 01 f7             	add    %r14,%r15
  40178d:	0f 1f 00             	nopl   (%rax)
    {
        ret.groups[i].move_funcs = memdup(ret.groups[i].move_funcs,
            sizeof(ret.groups[i].move_funcs[0]) *
                ((ret.groups[i].num & (~(MOVES_GROW_BY - 1))) + MOVES_GROW_BY));
  401790:	48 8b 45 08          	mov    0x8(%rbp),%rax
        ret.groups[i].move_funcs = memdup(ret.groups[i].move_funcs,
  401794:	48 8b 75 00          	mov    0x0(%rbp),%rsi
                ((ret.groups[i].num & (~(MOVES_GROW_BY - 1))) + MOVES_GROW_BY));
  401798:	48 83 e0 f0          	and    $0xfffffffffffffff0,%rax
        ret.groups[i].move_funcs = memdup(ret.groups[i].move_funcs,
  40179c:	48 8d 14 c5 80 00 00 	lea    0x80(,%rax,8),%rdx
  4017a3:	00 
  4017a4:	48 89 74 24 08       	mov    %rsi,0x8(%rsp)
    void *const dest = malloc(my_size);
  4017a9:	48 89 d7             	mov    %rdx,%rdi
  4017ac:	48 89 14 24          	mov    %rdx,(%rsp)
  4017b0:	e8 3b f9 ff ff       	callq  4010f0 <malloc@plt>
    if (dest == NULL)
  4017b5:	48 85 c0             	test   %rax,%rax
  4017b8:	74 66                	je     401820 <fc_solve_new_soft_thread+0x1c0>
    memcpy(dest, src, my_size);
  4017ba:	48 8b 14 24          	mov    (%rsp),%rdx
  4017be:	48 89 c7             	mov    %rax,%rdi
  4017c1:	48 81 c5 e8 00 00 00 	add    $0xe8,%rbp
  4017c8:	48 8b 74 24 08       	mov    0x8(%rsp),%rsi
  4017cd:	e8 0e f9 ff ff       	callq  4010e0 <memcpy@plt>
        ret.groups[i].move_funcs = memdup(ret.groups[i].move_funcs,
  4017d2:	48 89 85 18 ff ff ff 	mov    %rax,-0xe8(%rbp)
    for (size_t i = 0; i < num; ++i)
  4017d9:	4c 39 fd             	cmp    %r15,%rbp
  4017dc:	75 b2                	jne    401790 <fc_solve_new_soft_thread+0x130>
    soft_thread->by_depth_moves_order.by_depth_moves[0] =
  4017de:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  4017e5:	ff ff 7f 
  4017e8:	4d 89 6c 24 08       	mov    %r13,0x8(%r12)
  4017ed:	49 89 04 24          	mov    %rax,(%r12)
}

static inline void fc_solve_reset_soft_thread(
    fcs_soft_thread *const soft_thread)
{
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED);
  4017f1:	31 c0                	xor    %eax,%eax
  4017f3:	4d 89 74 24 10       	mov    %r14,0x10(%r12)
  4017f8:	66 89 83 e0 01 00 00 	mov    %ax,0x1e0(%rbx)

    return ret;
}
  4017ff:	48 83 c4 18          	add    $0x18,%rsp
  401803:	48 89 d8             	mov    %rbx,%rax
  401806:	5b                   	pop    %rbx
  401807:	5d                   	pop    %rbp
  401808:	41 5c                	pop    %r12
  40180a:	41 5d                	pop    %r13
  40180c:	41 5e                	pop    %r14
  40180e:	41 5f                	pop    %r15
  401810:	c3                   	retq   
  401811:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401818:	00 00 00 00 
  40181c:	0f 1f 40 00          	nopl   0x0(%rax)
        ret.groups[i].move_funcs = memdup(ret.groups[i].move_funcs,
  401820:	48 c7 45 00 00 00 00 	movq   $0x0,0x0(%rbp)
  401827:	00 
  401828:	48 81 c5 e8 00 00 00 	add    $0xe8,%rbp
    for (size_t i = 0; i < num; ++i)
  40182f:	49 39 ef             	cmp    %rbp,%r15
  401832:	0f 85 58 ff ff ff    	jne    401790 <fc_solve_new_soft_thread+0x130>
  401838:	eb a4                	jmp    4017de <fc_solve_new_soft_thread+0x17e>
  40183a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        return NULL;
  401840:	31 db                	xor    %ebx,%ebx
  401842:	eb bb                	jmp    4017ff <fc_solve_new_soft_thread+0x19f>
  401844:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40184b:	00 00 00 00 
  40184f:	90                   	nop

0000000000401850 <fc_solve_finish_instance>:
{
  401850:	41 57                	push   %r15
  401852:	49 89 ff             	mov    %rdi,%r15
  401855:	41 56                	push   %r14
  401857:	41 55                	push   %r13
  401859:	41 54                	push   %r12
  40185b:	55                   	push   %rbp
  40185c:	53                   	push   %rbx
  40185d:	48 83 ec 28          	sub    $0x28,%rsp
{
    char *iter, *iter_next;
    meta_allocator *const meta = allocator->meta;
    var_AUTO(bin, meta->recycle_bin);
    // Enqueue all the allocated buffers in the meta allocator for re-use.
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  401861:	49 8b 4f 38          	mov    0x38(%r15),%rcx
    meta_allocator *const meta = allocator->meta;
  401865:	48 8b 7f 58          	mov    0x58(%rdi),%rdi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  401869:	48 8b 11             	mov    (%rcx),%rdx
    var_AUTO(bin, meta->recycle_bin);
  40186c:	48 8b 37             	mov    (%rdi),%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40186f:	48 85 d2             	test   %rdx,%rdx
  401872:	75 12                	jne    401886 <fc_solve_finish_instance+0x36>
  401874:	e9 87 01 00 00       	jmpq   401a00 <fc_solve_finish_instance+0x1b0>
  401879:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  401880:	48 89 d1             	mov    %rdx,%rcx
  401883:	4c 89 c2             	mov    %r8,%rdx
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
    {
        OLD_LIST_NEXT(iter) = bin;
  401886:	48 89 31             	mov    %rsi,(%rcx)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  401889:	4c 8b 02             	mov    (%rdx),%r8
  40188c:	48 89 ce             	mov    %rcx,%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40188f:	4d 85 c0             	test   %r8,%r8
  401892:	75 ec                	jne    401880 <fc_solve_finish_instance+0x30>
        bin = iter;
    }

    OLD_LIST_NEXT(iter) = bin;
  401894:	48 89 0a             	mov    %rcx,(%rdx)
    meta->recycle_bin = iter;
  401897:	48 89 17             	mov    %rdx,(%rdi)
}

static inline void fc_solve_hash_free(hash_table *const hash)
{
    fc_solve_compact_allocator_finish(&(hash->allocator));
    free(hash->entries);
  40189a:	49 8b 7f 10          	mov    0x10(%r15),%rdi
  40189e:	e8 ad f7 ff ff       	callq  401050 <free@plt>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  4018a3:	49 8b 8f 88 00 00 00 	mov    0x88(%r15),%rcx
    hash->entries = NULL;
  4018aa:	49 c7 47 10 00 00 00 	movq   $0x0,0x10(%r15)
  4018b1:	00 
    meta_allocator *const meta = allocator->meta;
  4018b2:	49 8b bf a8 00 00 00 	mov    0xa8(%r15),%rdi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  4018b9:	48 8b 11             	mov    (%rcx),%rdx
    var_AUTO(bin, meta->recycle_bin);
  4018bc:	48 8b 37             	mov    (%rdi),%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  4018bf:	48 85 d2             	test   %rdx,%rdx
  4018c2:	75 12                	jne    4018d6 <fc_solve_finish_instance+0x86>
  4018c4:	e9 47 01 00 00       	jmpq   401a10 <fc_solve_finish_instance+0x1c0>
  4018c9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  4018d0:	48 89 d1             	mov    %rdx,%rcx
  4018d3:	4c 89 c2             	mov    %r8,%rdx
        OLD_LIST_NEXT(iter) = bin;
  4018d6:	48 89 31             	mov    %rsi,(%rcx)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  4018d9:	4c 8b 02             	mov    (%rdx),%r8
  4018dc:	48 89 ce             	mov    %rcx,%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  4018df:	4d 85 c0             	test   %r8,%r8
  4018e2:	75 ec                	jne    4018d0 <fc_solve_finish_instance+0x80>
    OLD_LIST_NEXT(iter) = bin;
  4018e4:	48 89 0a             	mov    %rcx,(%rdx)
    meta->recycle_bin = iter;
  4018e7:	48 89 17             	mov    %rdx,(%rdi)
    free(hash->entries);
  4018ea:	49 8b 7f 60          	mov    0x60(%r15),%rdi
  4018ee:	e8 5d f7 ff ff       	callq  401050 <free@plt>
    const int_fast32_t num_soft_threads =
  4018f3:	49 8b 87 20 05 00 00 	mov    0x520(%r15),%rax
    hash->entries = NULL;
  4018fa:	49 c7 47 60 00 00 00 	movq   $0x0,0x60(%r15)
  401901:	00 
  401902:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
        if (st_idx < num_soft_threads)
  401907:	48 85 c0             	test   %rax,%rax
  40190a:	0f 8e d8 00 00 00    	jle    4019e8 <fc_solve_finish_instance+0x198>
    for (int_fast32_t st_idx = 0; st_idx <= num_soft_threads; ++st_idx)
  401910:	48 c7 44 24 08 00 00 	movq   $0x0,0x8(%rsp)
  401917:	00 00 
        if (st_idx < num_soft_threads)
  401919:	45 31 f6             	xor    %r14d,%r14d
  40191c:	0f 1f 40 00          	nopl   0x0(%rax)
            soft_thread = &(instance->hard_thread.soft_threads[st_idx]);
  401920:	49 8b af c0 00 00 00 	mov    0xc0(%r15),%rbp
  401927:	4c 01 f5             	add    %r14,%rbp
    fcs_soft_dfs_stack_item *const soft_dfs_info =
  40192a:	4c 8b 6d 30          	mov    0x30(%rbp),%r13
    if (!soft_dfs_info)
  40192e:	4d 85 ed             	test   %r13,%r13
  401931:	0f 84 94 00 00 00    	je     4019cb <fc_solve_finish_instance+0x17b>
        info_ptr + DFS_VAR(soft_thread, depth);
  401937:	48 69 4d 38 b0 00 00 	imul   $0xb0,0x38(%rbp),%rcx
  40193e:	00 
    for (; info_ptr < max_info_ptr; ++info_ptr)
  40193f:	4c 89 eb             	mov    %r13,%rbx
        info_ptr + DFS_VAR(soft_thread, dfs_max_depth);
  401942:	4c 69 65 28 b0 00 00 	imul   $0xb0,0x28(%rbp),%r12
  401949:	00 
    const fcs_soft_dfs_stack_item *const max_info_ptr =
  40194a:	4c 01 e9             	add    %r13,%rcx
    const fcs_soft_dfs_stack_item *const dfs_max_info_ptr =
  40194d:	4d 01 ec             	add    %r13,%r12
    for (; info_ptr < max_info_ptr; ++info_ptr)
  401950:	49 39 cd             	cmp    %rcx,%r13
  401953:	73 59                	jae    4019ae <fc_solve_finish_instance+0x15e>
  401955:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40195c:	00 00 00 00 
        free(info_ptr->derived_states_list.states);
  401960:	48 8b 7b 10          	mov    0x10(%rbx),%rdi
  401964:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
    for (; info_ptr < max_info_ptr; ++info_ptr)
  401969:	48 81 c3 b0 00 00 00 	add    $0xb0,%rbx
        free(info_ptr->derived_states_list.states);
  401970:	e8 db f6 ff ff       	callq  401050 <free@plt>
        free(info_ptr->derived_states_random_indexes);
  401975:	48 8b 7b 88          	mov    -0x78(%rbx),%rdi
  401979:	e8 d2 f6 ff ff       	callq  401050 <free@plt>
    for (; info_ptr < max_info_ptr; ++info_ptr)
  40197e:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
  401983:	48 39 d9             	cmp    %rbx,%rcx
  401986:	77 d8                	ja     401960 <fc_solve_finish_instance+0x110>
    for (; info_ptr < dfs_max_info_ptr; ++info_ptr)
  401988:	49 39 dc             	cmp    %rbx,%r12
  40198b:	76 26                	jbe    4019b3 <fc_solve_finish_instance+0x163>
  40198d:	0f 1f 00             	nopl   (%rax)
        if (likely(info_ptr->derived_states_list.states))
  401990:	48 8b 7b 10          	mov    0x10(%rbx),%rdi
  401994:	48 85 ff             	test   %rdi,%rdi
  401997:	74 0e                	je     4019a7 <fc_solve_finish_instance+0x157>
            free(info_ptr->derived_states_list.states);
  401999:	e8 b2 f6 ff ff       	callq  401050 <free@plt>
            free(info_ptr->derived_states_random_indexes);
  40199e:	48 8b 7b 38          	mov    0x38(%rbx),%rdi
  4019a2:	e8 a9 f6 ff ff       	callq  401050 <free@plt>
    for (; info_ptr < dfs_max_info_ptr; ++info_ptr)
  4019a7:	48 81 c3 b0 00 00 00 	add    $0xb0,%rbx
  4019ae:	49 39 dc             	cmp    %rbx,%r12
  4019b1:	77 dd                	ja     401990 <fc_solve_finish_instance+0x140>
    free(soft_dfs_info);
  4019b3:	4c 89 ef             	mov    %r13,%rdi
  4019b6:	e8 95 f6 ff ff       	callq  401050 <free@plt>
    DFS_VAR(soft_thread, soft_dfs_info) = NULL;
  4019bb:	48 c7 45 30 00 00 00 	movq   $0x0,0x30(%rbp)
  4019c2:	00 
    DFS_VAR(soft_thread, dfs_max_depth) = 0;
  4019c3:	48 c7 45 28 00 00 00 	movq   $0x0,0x28(%rbp)
  4019ca:	00 
    for (int_fast32_t st_idx = 0; st_idx <= num_soft_threads; ++st_idx)
  4019cb:	48 83 44 24 08 01    	addq   $0x1,0x8(%rsp)
  4019d1:	49 81 c6 f8 01 00 00 	add    $0x1f8,%r14
  4019d8:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
        if (st_idx < num_soft_threads)
  4019dd:	48 39 44 24 10       	cmp    %rax,0x10(%rsp)
  4019e2:	0f 85 38 ff ff ff    	jne    401920 <fc_solve_finish_instance+0xd0>
}
  4019e8:	48 83 c4 28          	add    $0x28,%rsp
  4019ec:	5b                   	pop    %rbx
  4019ed:	5d                   	pop    %rbp
  4019ee:	41 5c                	pop    %r12
  4019f0:	41 5d                	pop    %r13
  4019f2:	41 5e                	pop    %r14
  4019f4:	41 5f                	pop    %r15
  4019f6:	c3                   	retq   
  4019f7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4019fe:	00 00 
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  401a00:	48 89 ca             	mov    %rcx,%rdx
    var_AUTO(bin, meta->recycle_bin);
  401a03:	48 89 f1             	mov    %rsi,%rcx
  401a06:	e9 89 fe ff ff       	jmpq   401894 <fc_solve_finish_instance+0x44>
  401a0b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  401a10:	48 89 ca             	mov    %rcx,%rdx
    var_AUTO(bin, meta->recycle_bin);
  401a13:	48 89 f1             	mov    %rsi,%rcx
  401a16:	e9 c9 fe ff ff       	jmpq   4018e4 <fc_solve_finish_instance+0x94>
  401a1b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

0000000000401a20 <fc_solve_sfs_check_state_begin>:
 * */
int fc_solve_sfs_check_state_begin(fcs_hard_thread *const hard_thread,
    fcs_kv_state *const out_new_state_out,
    fcs_kv_state raw_state_raw SFS__PASS_MOVE_STACK(
        fcs_move_stack *const moves))
{
  401a20:	53                   	push   %rbx
  401a21:	48 89 fb             	mov    %rdi,%rbx
  401a24:	48 83 ec 20          	sub    $0x20,%rsp
    fcs_collectible_state *raw_ptr_new_state;
    fcs_instance *const instance = HT_INSTANCE(hard_thread);

    if ((HT_FIELD(hard_thread, allocated_from_list) =
                (instance->list_of_vacant_states != NULL)))
  401a28:	48 8b bf b0 00 00 00 	mov    0xb0(%rdi),%rdi
  401a2f:	48 85 ff             	test   %rdi,%rdi
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  401a32:	0f 95 83 18 05 00 00 	setne  0x518(%rbx)
  401a39:	0f 84 91 00 00 00    	je     401ad0 <fc_solve_sfs_check_state_begin+0xb0>
    {
        raw_ptr_new_state = instance->list_of_vacant_states;
        instance->list_of_vacant_states =
            FCS_S_NEXT(instance->list_of_vacant_states);
  401a3f:	48 8b 47 48          	mov    0x48(%rdi),%rax
        instance->list_of_vacant_states =
  401a43:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
        raw_ptr_new_state =
            fcs_state_ia_alloc_into_var(&(HT_FIELD(hard_thread, allocator)));
    }

    FCS_STATE_collectible_to_kv(out_new_state_out, raw_ptr_new_state);
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  401a4a:	c5 fa 6f 12          	vmovdqu (%rdx),%xmm2
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  401a4e:	48 8d 47 48          	lea    0x48(%rdi),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  401a52:	c4 e1 f9 6e cf       	vmovq  %rdi,%xmm1
  401a57:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  401a5d:	c5 f8 11 06          	vmovups %xmm0,(%rsi)
  401a61:	c5 fa 6f 31          	vmovdqu (%rcx),%xmm6
  401a65:	c5 f8 11 17          	vmovups %xmm2,(%rdi)
  401a69:	c5 fa 6f 5a 10       	vmovdqu 0x10(%rdx),%xmm3
  401a6e:	c5 f8 11 5f 10       	vmovups %xmm3,0x10(%rdi)
  401a73:	c5 fa 6f 62 20       	vmovdqu 0x20(%rdx),%xmm4
  401a78:	c5 f8 11 67 20       	vmovups %xmm4,0x20(%rdi)
  401a7d:	c5 fa 6f 6a 30       	vmovdqu 0x30(%rdx),%xmm5
  401a82:	c5 f8 11 6f 30       	vmovups %xmm5,0x30(%rdi)
  401a87:	48 8b 42 40          	mov    0x40(%rdx),%rax
  401a8b:	c5 f8 11 77 48       	vmovups %xmm6,0x48(%rdi)
  401a90:	48 89 47 40          	mov    %rax,0x40(%rdi)
  401a94:	48 8b 41 10          	mov    0x10(%rcx),%rax
#endif
/* Make sure depth is consistent with the game graph.
 * I.e: the depth of every newly discovered state is derived from
 * the state from which it was discovered. */
#ifndef FCS_WITHOUT_DEPTH_FIELD
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  401a98:	83 47 50 01          	addl   $0x1,0x50(%rdi)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  401a9c:	48 89 57 48          	mov    %rdx,0x48(%rdi)
#endif
    /* Mark this state as a state that was not yet visited */
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  401aa0:	c6 47 56 00          	movb   $0x0,0x56(%rdi)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  401aa4:	48 89 47 58          	mov    %rax,0x58(%rdi)
    /* It's a newly created state which does not have children yet. */
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  401aa8:	31 c0                	xor    %eax,%eax
  401aaa:	66 89 47 54          	mov    %ax,0x54(%rdi)
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
        sizeof(FCS_S_SCAN_VISITED(raw_ptr_new_state)));
    fcs_move_stack_reset(moves);

    return 0;
}
  401aae:	31 c0                	xor    %eax,%eax
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  401ab0:	c7 47 5c 00 00 00 00 	movl   $0x0,0x5c(%rdi)
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  401ab7:	c7 47 57 00 00 00 00 	movl   $0x0,0x57(%rdi)
}
  401abe:	48 83 c4 20          	add    $0x20,%rsp
  401ac2:	5b                   	pop    %rbx
  401ac3:	c3                   	retq   
  401ac4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401acb:	00 00 00 00 
  401acf:	90                   	nop
    const size_t how_much =
        how_much_proto +
        ((sizeof(char *) - ((how_much_proto) & (sizeof(char *) - 1))) &
            (sizeof(char *) - 1));

    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  401ad0:	48 8b bb e8 00 00 00 	mov    0xe8(%rbx),%rdi
  401ad7:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
  401ade:	48 29 f8             	sub    %rdi,%rax
  401ae1:	48 83 f8 5f          	cmp    $0x5f,%rax
  401ae5:	76 19                	jbe    401b00 <fc_solve_sfs_check_state_begin+0xe0>
    {
        fc_solve_compact_allocator_extend(allocator);
    }
    else
    {
        allocator->rollback_ptr = allocator->ptr;
  401ae7:	48 89 bb f0 00 00 00 	mov    %rdi,0xf0(%rbx)
    }
    allocator->ptr += how_much;
  401aee:	48 8d 47 60          	lea    0x60(%rdi),%rax
  401af2:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)

    return allocator->rollback_ptr;
  401af9:	e9 4c ff ff ff       	jmpq   401a4a <fc_solve_sfs_check_state_begin+0x2a>
  401afe:	66 90                	xchg   %ax,%ax
    char *const new_data = meta_request_new_buffer(allocator->meta);
  401b00:	48 8b bb f8 00 00 00 	mov    0xf8(%rbx),%rdi
    char *const ret = meta_alloc->recycle_bin;
  401b07:	48 8b 07             	mov    (%rdi),%rax
    if (ret)
  401b0a:	48 85 c0             	test   %rax,%rax
  401b0d:	74 31                	je     401b40 <fc_solve_sfs_check_state_begin+0x120>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  401b0f:	4c 8b 00             	mov    (%rax),%r8
  401b12:	4c 89 07             	mov    %r8,(%rdi)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  401b15:	48 8b bb d8 00 00 00 	mov    0xd8(%rbx),%rdi
  401b1c:	48 89 38             	mov    %rdi,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  401b1f:	48 8d 78 08          	lea    0x8(%rax),%rdi
    allocator->old_list = new_data;
  401b23:	48 89 83 d8 00 00 00 	mov    %rax,0xd8(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  401b2a:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  401b30:	48 89 bb f0 00 00 00 	mov    %rdi,0xf0(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  401b37:	48 89 83 e0 00 00 00 	mov    %rax,0xe0(%rbx)
  401b3e:	eb ae                	jmp    401aee <fc_solve_sfs_check_state_begin+0xce>
        return malloc(ALLOCED_SIZE);
  401b40:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  401b45:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
  401b4a:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  401b4f:	48 89 74 24 08       	mov    %rsi,0x8(%rsp)
  401b54:	e8 97 f5 ff ff       	callq  4010f0 <malloc@plt>
  401b59:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
  401b5e:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  401b63:	48 8b 74 24 08       	mov    0x8(%rsp),%rsi
  401b68:	eb ab                	jmp    401b15 <fc_solve_sfs_check_state_begin+0xf5>
  401b6a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

0000000000401b70 <fc_solve_check_and_add_state>:
    handle_existing_void(                                                      \
        instance, hard_thread, new_state, existing_state_raw, (existing_void))

bool fc_solve_check_and_add_state(fcs_hard_thread *const hard_thread,
    fcs_kv_state *const new_state, fcs_kv_state *const existing_state_raw)
{
  401b70:	41 57                	push   %r15
  401b72:	41 56                	push   %r14
  401b74:	41 55                	push   %r13
        p+=4;
    }

    while (p<bEnd) {
        h64 ^= (*p) * PRIME64_5;
        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
  401b76:	49 bd 87 ca eb 85 b1 	movabs $0x9e3779b185ebca87,%r13
  401b7d:	79 37 9e 
  401b80:	41 54                	push   %r12
  401b82:	55                   	push   %rbp
  401b83:	53                   	push   %rbx
  401b84:	48 89 fb             	mov    %rdi,%rbx
  401b87:	48 83 ec 48          	sub    $0x48,%rsp
#ifdef FCS_SINGLE_HARD_THREAD
#define instance hard_thread
#else
    fcs_instance *const instance = hard_thread->instance;
#endif
    fc_solve_cache_stacks(hard_thread, new_state);
  401b8b:	48 8b 7e 08          	mov    0x8(%rsi),%rdi
    fcs_cards_column *current_stack = new_state_key->columns;
  401b8f:	48 8b 06             	mov    (%rsi),%rax
{
  401b92:	48 89 74 24 18       	mov    %rsi,0x18(%rsp)
  401b97:	48 89 54 24 38       	mov    %rdx,0x38(%rsp)
    for (int i = 0; i < LOCAL_STACKS_NUM; ++i, ++current_stack)
  401b9c:	c7 44 24 0c 00 00 00 	movl   $0x0,0xc(%rsp)
  401ba3:	00 
    fc_solve_cache_stacks(hard_thread, new_state);
  401ba4:	48 89 7c 24 20       	mov    %rdi,0x20(%rsp)
    fcs_cards_column *current_stack = new_state_key->columns;
  401ba9:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
    for (int i = 0; i < LOCAL_STACKS_NUM; ++i, ++current_stack)
  401bae:	66 90                	xchg   %ax,%ax
        if (!(new_state_info->stacks_copy_on_write_flags & (1 << i)))
  401bb0:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  401bb5:	8b 7c 24 0c          	mov    0xc(%rsp),%edi
  401bb9:	8b 40 14             	mov    0x14(%rax),%eax
  401bbc:	0f a3 f8             	bt     %edi,%eax
  401bbf:	0f 83 78 03 00 00    	jae    401f3d <fc_solve_check_and_add_state+0x3cd>
        var_AUTO(column, fcs_state_get_col(*(new_state_key), i));
  401bc5:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  401bca:	48 8b ab e8 00 00 00 	mov    0xe8(%rbx),%rbp
  401bd1:	48 8b 30             	mov    (%rax),%rsi
  401bd4:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
        const int col_len = (fcs_col_len(column) + 1);
  401bdb:	44 0f be 26          	movsbl (%rsi),%r12d
  401bdf:	48 29 e8             	sub    %rbp,%rax
  401be2:	41 83 c4 01          	add    $0x1,%r12d
            (char *)fcs_compact_alloc_ptr(stacks_allocator, col_len);
  401be6:	4d 63 e4             	movslq %r12d,%r12
        ((sizeof(char *) - ((how_much_proto) & (sizeof(char *) - 1))) &
  401be9:	4d 89 e6             	mov    %r12,%r14
  401bec:	49 f7 de             	neg    %r14
  401bef:	41 83 e6 07          	and    $0x7,%r14d
    const size_t how_much =
  401bf3:	4d 01 e6             	add    %r12,%r14
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  401bf6:	49 39 c6             	cmp    %rax,%r14
  401bf9:	0f 87 21 06 00 00    	ja     402220 <fc_solve_check_and_add_state+0x6b0>
    allocator->ptr += how_much;
  401bff:	49 01 ee             	add    %rbp,%r14
        allocator->rollback_ptr = allocator->ptr;
  401c02:	48 89 ab f0 00 00 00 	mov    %rbp,0xf0(%rbx)
    allocator->ptr += how_much;
  401c09:	4c 89 b3 e8 00 00 00 	mov    %r14,0xe8(%rbx)
        memcpy(new_ptr, column, col_len);
  401c10:	49 83 fc 08          	cmp    $0x8,%r12
  401c14:	0f 83 5c 06 00 00    	jae    402276 <fc_solve_check_and_add_state+0x706>
  401c1a:	41 f6 c4 04          	test   $0x4,%r12b
  401c1e:	0f 85 1c 0a 00 00    	jne    402640 <fc_solve_check_and_add_state+0xad0>
  401c24:	4d 85 e4             	test   %r12,%r12
  401c27:	74 10                	je     401c39 <fc_solve_check_and_add_state+0xc9>
  401c29:	0f b6 06             	movzbl (%rsi),%eax
  401c2c:	88 45 00             	mov    %al,0x0(%rbp)
  401c2f:	41 f6 c4 02          	test   $0x2,%r12b
  401c33:	0f 85 c7 0a 00 00    	jne    402700 <fc_solve_check_and_add_state+0xb90>
        *(current_stack) = new_ptr;
  401c39:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
    const BYTE* bEnd = p + len;
  401c3e:	4e 8d 5c 25 00       	lea    0x0(%rbp,%r12,1),%r11
    if (len>=32) {
  401c43:	48 89 ea             	mov    %rbp,%rdx
  401c46:	48 89 28             	mov    %rbp,(%rax)
        h64  = seed + PRIME64_5;
  401c49:	48 b8 c5 67 56 16 2f 	movabs $0x27d4eb2f165667c5,%rax
  401c50:	eb d4 27 
    if (len>=32) {
  401c53:	49 83 fc 1f          	cmp    $0x1f,%r12
  401c57:	0f 86 3a 01 00 00    	jbe    401d97 <fc_solve_check_and_add_state+0x227>
        const BYTE* const limit = bEnd - 32;
  401c5d:	4d 8d 7b e0          	lea    -0x20(%r11),%r15
        U64 v3 = seed + 0;
  401c61:	31 f6                	xor    %esi,%esi
        U64 v4 = seed - PRIME64_1;
  401c63:	48 b8 79 35 14 7a 4e 	movabs $0x61c8864e7a143579,%rax
  401c6a:	86 c8 61 
        U64 v2 = seed + PRIME64_2;
  401c6d:	48 bf 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%rdi
  401c74:	ae b2 c2 
        U64 v1 = seed + PRIME64_1 + PRIME64_2;
  401c77:	49 be d6 b5 c0 ad ee 	movabs $0x60ea27eeadc0b5d6,%r14
  401c7e:	27 ea 60 
  401c81:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401c88:	00 00 00 00 
  401c8c:	0f 1f 40 00          	nopl   0x0(%rax)
    acc += input * PRIME64_2;
  401c90:	48 b9 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%rcx
  401c97:	ae b2 c2 
  401c9a:	48 83 c2 20          	add    $0x20,%rdx
  401c9e:	49 ba 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%r10
  401ca5:	ae b2 c2 
  401ca8:	48 0f af 4a e0       	imul   -0x20(%rdx),%rcx
  401cad:	49 b9 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%r9
  401cb4:	ae b2 c2 
  401cb7:	49 b8 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%r8
  401cbe:	ae b2 c2 
  401cc1:	4c 0f af 52 e8       	imul   -0x18(%rdx),%r10
  401cc6:	4c 0f af 4a f0       	imul   -0x10(%rdx),%r9
  401ccb:	4c 0f af 42 f8       	imul   -0x8(%rdx),%r8
  401cd0:	4c 01 f1             	add    %r14,%rcx
  401cd3:	49 01 fa             	add    %rdi,%r10
    acc  = XXH_rotl64(acc, 31);
  401cd6:	48 c1 c1 1f          	rol    $0x1f,%rcx
    acc += input * PRIME64_2;
  401cda:	49 01 f1             	add    %rsi,%r9
    acc  = XXH_rotl64(acc, 31);
  401cdd:	49 c1 c2 1f          	rol    $0x1f,%r10
    acc *= PRIME64_1;
  401ce1:	49 89 ce             	mov    %rcx,%r14
    acc += input * PRIME64_2;
  401ce4:	49 01 c0             	add    %rax,%r8
    acc  = XXH_rotl64(acc, 31);
  401ce7:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  401ceb:	4c 89 d7             	mov    %r10,%rdi
  401cee:	4d 0f af f5          	imul   %r13,%r14
    acc  = XXH_rotl64(acc, 31);
  401cf2:	49 c1 c0 1f          	rol    $0x1f,%r8
    acc *= PRIME64_1;
  401cf6:	4c 89 ce             	mov    %r9,%rsi
  401cf9:	49 0f af fd          	imul   %r13,%rdi
  401cfd:	4c 89 c0             	mov    %r8,%rax
  401d00:	49 0f af f5          	imul   %r13,%rsi
  401d04:	49 0f af c5          	imul   %r13,%rax
        } while (p<=limit);
  401d08:	49 39 d7             	cmp    %rdx,%r15
  401d0b:	73 83                	jae    401c90 <fc_solve_check_and_add_state+0x120>
    acc += input * PRIME64_2;
  401d0d:	49 bf a9 6c 79 0f 01 	movabs $0xdef35b010f796ca9,%r15
  401d14:	5b f3 de 
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401d17:	48 c1 c7 07          	rol    $0x7,%rdi
    acc += input * PRIME64_2;
  401d1b:	49 0f af cf          	imul   %r15,%rcx
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401d1f:	49 d1 c6             	rol    %r14
  401d22:	48 c1 c6 0c          	rol    $0xc,%rsi
  401d26:	49 01 fe             	add    %rdi,%r14
    acc += input * PRIME64_2;
  401d29:	4c 89 d7             	mov    %r10,%rdi
  401d2c:	49 0f af ff          	imul   %r15,%rdi
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401d30:	48 c1 c0 12          	rol    $0x12,%rax
  401d34:	49 01 f6             	add    %rsi,%r14
    acc += input * PRIME64_2;
  401d37:	4d 0f af cf          	imul   %r15,%r9
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401d3b:	49 01 c6             	add    %rax,%r14
    acc += input * PRIME64_2;
  401d3e:	4d 0f af c7          	imul   %r15,%r8
    acc  = XXH_rotl64(acc, 31);
  401d42:	48 c1 c1 1f          	rol    $0x1f,%rcx
    acc *= PRIME64_1;
  401d46:	49 0f af cd          	imul   %r13,%rcx
    acc  = XXH_rotl64(acc, 31);
  401d4a:	48 c1 c7 1f          	rol    $0x1f,%rdi
    acc *= PRIME64_1;
  401d4e:	49 0f af fd          	imul   %r13,%rdi
    acc  = XXH_rotl64(acc, 31);
  401d52:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  401d56:	4d 0f af cd          	imul   %r13,%r9
    acc  = XXH_rotl64(acc, 31);
  401d5a:	49 c1 c0 1f          	rol    $0x1f,%r8
    acc *= PRIME64_1;
  401d5e:	4d 0f af c5          	imul   %r13,%r8
    acc ^= val;
  401d62:	49 31 ce             	xor    %rcx,%r14
    acc  = acc * PRIME64_1 + PRIME64_4;
  401d65:	48 b9 63 ae b2 c2 77 	movabs $0x85ebca77c2b2ae63,%rcx
  401d6c:	ca eb 85 
  401d6f:	4d 0f af f5          	imul   %r13,%r14
  401d73:	49 8d 04 0e          	lea    (%r14,%rcx,1),%rax
    acc ^= val;
  401d77:	48 31 f8             	xor    %rdi,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  401d7a:	49 0f af c5          	imul   %r13,%rax
  401d7e:	48 8d 04 08          	lea    (%rax,%rcx,1),%rax
    acc ^= val;
  401d82:	4c 31 c8             	xor    %r9,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  401d85:	49 0f af c5          	imul   %r13,%rax
  401d89:	48 8d 04 08          	lea    (%rax,%rcx,1),%rax
    acc ^= val;
  401d8d:	4c 31 c0             	xor    %r8,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  401d90:	49 0f af c5          	imul   %r13,%rax
  401d94:	48 01 c8             	add    %rcx,%rax
    while (p+8<=bEnd) {
  401d97:	48 8d 72 08          	lea    0x8(%rdx),%rsi
    h64 += (U64) len;
  401d9b:	4c 01 e0             	add    %r12,%rax
    while (p+8<=bEnd) {
  401d9e:	49 39 f3             	cmp    %rsi,%r11
  401da1:	72 60                	jb     401e03 <fc_solve_check_and_add_state+0x293>
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
  401da3:	48 bf 63 ae b2 c2 77 	movabs $0x85ebca77c2b2ae63,%rdi
  401daa:	ca eb 85 
  401dad:	48 89 f1             	mov    %rsi,%rcx
  401db0:	49 89 c0             	mov    %rax,%r8
  401db3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401dba:	00 00 00 00 
  401dbe:	66 90                	xchg   %ax,%ax
    acc += input * PRIME64_2;
  401dc0:	48 b8 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%rax
  401dc7:	ae b2 c2 
  401dca:	48 83 c1 08          	add    $0x8,%rcx
  401dce:	48 0f af 41 f0       	imul   -0x10(%rcx),%rax
    acc  = XXH_rotl64(acc, 31);
  401dd3:	48 c1 c0 1f          	rol    $0x1f,%rax
    acc *= PRIME64_1;
  401dd7:	49 0f af c5          	imul   %r13,%rax
        h64 ^= k1;
  401ddb:	4c 31 c0             	xor    %r8,%rax
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
  401dde:	48 c1 c0 1b          	rol    $0x1b,%rax
  401de2:	49 0f af c5          	imul   %r13,%rax
  401de6:	4c 8d 04 38          	lea    (%rax,%rdi,1),%r8
    while (p+8<=bEnd) {
  401dea:	49 39 cb             	cmp    %rcx,%r11
  401ded:	73 d1                	jae    401dc0 <fc_solve_check_and_add_state+0x250>
  401def:	49 8d 4b f8          	lea    -0x8(%r11),%rcx
  401df3:	4c 89 c0             	mov    %r8,%rax
  401df6:	48 29 d1             	sub    %rdx,%rcx
  401df9:	48 89 ca             	mov    %rcx,%rdx
  401dfc:	48 83 e2 f8          	and    $0xfffffffffffffff8,%rdx
  401e00:	48 01 f2             	add    %rsi,%rdx
    if (p+4<=bEnd) {
  401e03:	48 8d 4a 04          	lea    0x4(%rdx),%rcx
  401e07:	49 39 cb             	cmp    %rcx,%r11
  401e0a:	72 2c                	jb     401e38 <fc_solve_check_and_add_state+0x2c8>
        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
  401e0c:	44 8b 22             	mov    (%rdx),%r12d
        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
  401e0f:	48 89 ca             	mov    %rcx,%rdx
        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
  401e12:	4d 0f af e5          	imul   %r13,%r12
  401e16:	49 31 c4             	xor    %rax,%r12
        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
  401e19:	48 b8 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%rax
  401e20:	ae b2 c2 
  401e23:	49 c1 c4 17          	rol    $0x17,%r12
  401e27:	4c 0f af e0          	imul   %rax,%r12
  401e2b:	48 b8 f9 79 37 9e b1 	movabs $0x165667b19e3779f9,%rax
  401e32:	67 56 16 
  401e35:	4c 01 e0             	add    %r12,%rax
    while (p<bEnd) {
  401e38:	49 39 d3             	cmp    %rdx,%r11
  401e3b:	76 28                	jbe    401e65 <fc_solve_check_and_add_state+0x2f5>
  401e3d:	0f 1f 00             	nopl   (%rax)
        h64 ^= (*p) * PRIME64_5;
  401e40:	0f b6 0a             	movzbl (%rdx),%ecx
        p++;
  401e43:	48 83 c2 01          	add    $0x1,%rdx
        h64 ^= (*p) * PRIME64_5;
  401e47:	48 bf c5 67 56 16 2f 	movabs $0x27d4eb2f165667c5,%rdi
  401e4e:	eb d4 27 
  401e51:	48 0f af cf          	imul   %rdi,%rcx
  401e55:	48 31 c8             	xor    %rcx,%rax
        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
  401e58:	48 c1 c0 0b          	rol    $0xb,%rax
  401e5c:	49 0f af c5          	imul   %r13,%rax
    while (p<bEnd) {
  401e60:	49 39 d3             	cmp    %rdx,%r11
  401e63:	75 db                	jne    401e40 <fc_solve_check_and_add_state+0x2d0>
    }

    h64 ^= h64 >> 33;
  401e65:	49 89 c4             	mov    %rax,%r12
        (hash->entries + (hash_value & (hash->size_bitmask)));
  401e68:	4c 8b 73 60          	mov    0x60(%rbx),%r14
  401e6c:	49 c1 ec 21          	shr    $0x21,%r12
  401e70:	49 31 c4             	xor    %rax,%r12
    h64 *= PRIME64_2;
  401e73:	48 b8 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%rax
  401e7a:	ae b2 c2 
  401e7d:	4c 0f af e0          	imul   %rax,%r12
    h64 ^= h64 >> 29;
  401e81:	4c 89 e0             	mov    %r12,%rax
  401e84:	48 c1 e8 1d          	shr    $0x1d,%rax
  401e88:	49 31 c4             	xor    %rax,%r12
    h64 *= PRIME64_3;
  401e8b:	48 b8 f9 79 37 9e b1 	movabs $0x165667b19e3779f9,%rax
  401e92:	67 56 16 
  401e95:	4c 0f af e0          	imul   %rax,%r12
    h64 ^= h64 >> 32;
  401e99:	4c 89 e0             	mov    %r12,%rax
  401e9c:	48 c1 e8 20          	shr    $0x20,%rax
  401ea0:	49 31 c4             	xor    %rax,%r12
  401ea3:	48 63 43 70          	movslq 0x70(%rbx),%rax
  401ea7:	4c 21 e0             	and    %r12,%rax
    typeof(hash->entries[0]) *const list =
  401eaa:	49 8d 04 c6          	lea    (%r14,%rax,8),%rax
    if (list->first_item == NULL)
  401eae:	4c 8b 38             	mov    (%rax),%r15
  401eb1:	4d 85 ff             	test   %r15,%r15
  401eb4:	0f 84 46 04 00 00    	je     402300 <fc_solve_check_and_add_state+0x790>
    const_SLOT(hash_type, hash);
  401eba:	44 8b 43 68          	mov    0x68(%rbx),%r8d
  401ebe:	4c 89 f1             	mov    %r14,%rcx
  401ec1:	45 89 c6             	mov    %r8d,%r14d
  401ec4:	49 89 d8             	mov    %rbx,%r8
  401ec7:	4c 89 e3             	mov    %r12,%rbx
  401eca:	49 89 ec             	mov    %rbp,%r12
  401ecd:	eb 11                	jmp    401ee0 <fc_solve_check_and_add_state+0x370>
  401ecf:	90                   	nop
            item = item->next;
  401ed0:	49 8b 47 10          	mov    0x10(%r15),%rax
        while (item != NULL)
  401ed4:	48 85 c0             	test   %rax,%rax
  401ed7:	0f 84 f3 04 00 00    	je     4023d0 <fc_solve_check_and_add_state+0x860>
  401edd:	49 89 c7             	mov    %rax,%r15
            if ((item->hash_value == hash_value)
  401ee0:	49 39 5f 08          	cmp    %rbx,0x8(%r15)
  401ee4:	75 ea                	jne    401ed0 <fc_solve_check_and_add_state+0x360>
  401ee6:	49 8b 2f             	mov    (%r15),%rbp
                && MY_HASH_COMPARE())
  401ee9:	45 85 f6             	test   %r14d,%r14d
  401eec:	0f 84 ae 03 00 00    	je     4022a0 <fc_solve_check_and_add_state+0x730>
    return memcmp(s1, s2, sizeof(fcs_state));
  401ef2:	ba 48 00 00 00       	mov    $0x48,%edx
  401ef7:	4c 89 e6             	mov    %r12,%rsi
  401efa:	48 89 ef             	mov    %rbp,%rdi
  401efd:	4c 89 44 24 30       	mov    %r8,0x30(%rsp)
  401f02:	48 89 4c 24 28       	mov    %rcx,0x28(%rsp)
  401f07:	e8 74 f1 ff ff       	callq  401080 <memcmp@plt>
  401f0c:	4c 8b 44 24 30       	mov    0x30(%rsp),%r8
  401f11:	48 8b 4c 24 28       	mov    0x28(%rsp),%rcx
  401f16:	85 c0                	test   %eax,%eax
  401f18:	0f 94 c0             	sete   %al
  401f1b:	84 c0                	test   %al,%al
  401f1d:	74 b1                	je     401ed0 <fc_solve_check_and_add_state+0x360>
  401f1f:	4c 89 c3             	mov    %r8,%rbx
        REPLACE_WITH_CACHED(cached_stack);
  401f22:	48 85 ed             	test   %rbp,%rbp
  401f25:	74 16                	je     401f3d <fc_solve_check_and_add_state+0x3cd>
}

static inline void fcs_compact_alloc_release(compact_allocator *const allocator)
{
    allocator->ptr = allocator->rollback_ptr;
  401f27:	49 8b 80 f0 00 00 00 	mov    0xf0(%r8),%rax
  401f2e:	49 89 80 e8 00 00 00 	mov    %rax,0xe8(%r8)
  401f35:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
  401f3a:	48 89 28             	mov    %rbp,(%rax)
    for (int i = 0; i < LOCAL_STACKS_NUM; ++i, ++current_stack)
  401f3d:	83 44 24 0c 01       	addl   $0x1,0xc(%rsp)
  401f42:	8b 44 24 0c          	mov    0xc(%rsp),%eax
  401f46:	48 83 44 24 10 08    	addq   $0x8,0x10(%rsp)
  401f4c:	83 f8 08             	cmp    $0x8,%eax
  401f4f:	0f 85 5b fc ff ff    	jne    401bb0 <fc_solve_check_and_add_state+0x40>
    fc_solve_canonize_state(new_state_key PASS_FREECELLS(INSTANCE_FREECELLS_NUM)
  401f55:	4c 8b 7c 24 18       	mov    0x18(%rsp),%r15
  401f5a:	49 8b 3f             	mov    (%r15),%rdi
  401f5d:	e8 de f5 ff ff       	callq  401540 <fc_solve_canonize_state>
#ifdef FCS_ENABLE_SECONDARY_HASH_VALUE
#define B , hash_value_int
#else
#define B
#endif
    return HANDLE_existing_void(fc_solve_hash_insert(
  401f62:	49 8b 2f             	mov    (%r15),%rbp
    acc += input * PRIME64_2;
  401f65:	48 be 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%rsi
  401f6c:	ae b2 c2 
  401f6f:	48 b8 d6 b5 c0 ad ee 	movabs $0x60ea27eeadc0b5d6,%rax
  401f76:	27 ea 60 
    acc *= PRIME64_1;
  401f79:	48 b9 87 ca eb 85 b1 	movabs $0x9e3779b185ebca87,%rcx
  401f80:	79 37 9e 
    acc += input * PRIME64_2;
  401f83:	49 bb a9 6c 79 0f 01 	movabs $0xdef35b010f796ca9,%r11
  401f8a:	5b f3 de 
  401f8d:	4c 8b 6d 00          	mov    0x0(%rbp),%r13
    const BYTE* bEnd = p + len;
  401f91:	48 8d 7d 48          	lea    0x48(%rbp),%rdi
    acc += input * PRIME64_2;
  401f95:	4c 8b 55 18          	mov    0x18(%rbp),%r10
  401f99:	48 8b 55 10          	mov    0x10(%rbp),%rdx
  401f9d:	4c 8b 75 20          	mov    0x20(%rbp),%r14
  401fa1:	4c 0f af ee          	imul   %rsi,%r13
  401fa5:	4c 0f af d6          	imul   %rsi,%r10
  401fa9:	48 0f af d6          	imul   %rsi,%rdx
  401fad:	4c 0f af f6          	imul   %rsi,%r14
  401fb1:	49 01 c5             	add    %rax,%r13
  401fb4:	48 8b 45 08          	mov    0x8(%rbp),%rax
    acc  = XXH_rotl64(acc, 31);
  401fb8:	49 c1 c5 1f          	rol    $0x1f,%r13
    acc *= PRIME64_1;
  401fbc:	4c 0f af e9          	imul   %rcx,%r13
    acc  = XXH_rotl64(acc, 31);
  401fc0:	48 c1 c2 1f          	rol    $0x1f,%rdx
    acc *= PRIME64_1;
  401fc4:	48 0f af d1          	imul   %rcx,%rdx
    acc += input * PRIME64_2;
  401fc8:	4c 8d 48 01          	lea    0x1(%rax),%r9
  401fcc:	48 b8 79 35 14 7a 4e 	movabs $0x61c8864e7a143579,%rax
  401fd3:	86 c8 61 
  401fd6:	4c 0f af ce          	imul   %rsi,%r9
  401fda:	49 01 c2             	add    %rax,%r10
  401fdd:	48 8b 45 28          	mov    0x28(%rbp),%rax
    acc  = XXH_rotl64(acc, 31);
  401fe1:	49 c1 c2 1f          	rol    $0x1f,%r10
    acc *= PRIME64_1;
  401fe5:	4c 0f af d1          	imul   %rcx,%r10
    acc += input * PRIME64_2;
  401fe9:	4d 01 f5             	add    %r14,%r13
    acc  = XXH_rotl64(acc, 31);
  401fec:	49 c1 c5 1f          	rol    $0x1f,%r13
    acc += input * PRIME64_2;
  401ff0:	48 0f af c6          	imul   %rsi,%rax
  401ff4:	4d 89 ec             	mov    %r13,%r12
    acc *= PRIME64_1;
  401ff7:	4c 0f af e9          	imul   %rcx,%r13
    acc  = XXH_rotl64(acc, 31);
  401ffb:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  401fff:	4c 0f af c9          	imul   %rcx,%r9
    acc += input * PRIME64_2;
  402003:	4d 0f af e3          	imul   %r11,%r12
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  402007:	4d 89 ee             	mov    %r13,%r14
    acc += input * PRIME64_2;
  40200a:	49 01 c1             	add    %rax,%r9
  40200d:	48 8b 45 30          	mov    0x30(%rbp),%rax
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  402011:	49 d1 c6             	rol    %r14
    acc  = XXH_rotl64(acc, 31);
  402014:	49 c1 c1 1f          	rol    $0x1f,%r9
  402018:	49 c1 c4 1f          	rol    $0x1f,%r12
    acc *= PRIME64_1;
  40201c:	4d 89 c8             	mov    %r9,%r8
  40201f:	4c 0f af c1          	imul   %rcx,%r8
    acc += input * PRIME64_2;
  402023:	48 0f af c6          	imul   %rsi,%rax
  402027:	48 01 c2             	add    %rax,%rdx
  40202a:	48 8b 45 38          	mov    0x38(%rbp),%rax
    acc  = XXH_rotl64(acc, 31);
  40202e:	48 c1 c2 1f          	rol    $0x1f,%rdx
    acc += input * PRIME64_2;
  402032:	48 0f af c6          	imul   %rsi,%rax
  402036:	49 01 c2             	add    %rax,%r10
    acc *= PRIME64_1;
  402039:	48 89 d0             	mov    %rdx,%rax
    acc  = XXH_rotl64(acc, 31);
  40203c:	49 c1 c2 1f          	rol    $0x1f,%r10
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  402040:	49 c1 c0 07          	rol    $0x7,%r8
    acc *= PRIME64_1;
  402044:	48 0f af c1          	imul   %rcx,%rax
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  402048:	4f 8d 2c 06          	lea    (%r14,%r8,1),%r13
    acc *= PRIME64_1;
  40204c:	4c 0f af e1          	imul   %rcx,%r12
    acc += input * PRIME64_2;
  402050:	4d 0f af cb          	imul   %r11,%r9
  402054:	49 0f af d3          	imul   %r11,%rdx
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  402058:	48 c1 c0 0c          	rol    $0xc,%rax
  40205c:	4d 8d 44 05 00       	lea    0x0(%r13,%rax,1),%r8
    acc *= PRIME64_1;
  402061:	4c 89 d0             	mov    %r10,%rax
  402064:	48 0f af c1          	imul   %rcx,%rax
    acc += input * PRIME64_2;
  402068:	4d 0f af d3          	imul   %r11,%r10
    acc  = XXH_rotl64(acc, 31);
  40206c:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  402070:	4c 0f af c9          	imul   %rcx,%r9
    acc  = XXH_rotl64(acc, 31);
  402074:	48 c1 c2 1f          	rol    $0x1f,%rdx
    acc *= PRIME64_1;
  402078:	48 0f af d1          	imul   %rcx,%rdx
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  40207c:	48 c1 c0 12          	rol    $0x12,%rax
  402080:	4c 01 c0             	add    %r8,%rax
    acc  = XXH_rotl64(acc, 31);
  402083:	49 c1 c2 1f          	rol    $0x1f,%r10
    acc  = acc * PRIME64_1 + PRIME64_4;
  402087:	49 b8 63 ae b2 c2 77 	movabs $0x85ebca77c2b2ae63,%r8
  40208e:	ca eb 85 
    acc *= PRIME64_1;
  402091:	4c 0f af d1          	imul   %rcx,%r10
    acc ^= val;
  402095:	4c 31 e0             	xor    %r12,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  402098:	48 0f af c1          	imul   %rcx,%rax
  40209c:	4a 8d 04 00          	lea    (%rax,%r8,1),%rax
    acc ^= val;
  4020a0:	4c 31 c8             	xor    %r9,%rax
    while (p+8<=bEnd) {
  4020a3:	49 89 f9             	mov    %rdi,%r9
    acc  = acc * PRIME64_1 + PRIME64_4;
  4020a6:	48 0f af c1          	imul   %rcx,%rax
  4020aa:	4a 8d 04 00          	lea    (%rax,%r8,1),%rax
    acc ^= val;
  4020ae:	48 31 d0             	xor    %rdx,%rax
    h64 += (U64) len;
  4020b1:	48 ba ab ae b2 c2 77 	movabs $0x85ebca77c2b2aeab,%rdx
  4020b8:	ca eb 85 
    acc  = acc * PRIME64_1 + PRIME64_4;
  4020bb:	48 0f af c1          	imul   %rcx,%rax
  4020bf:	4a 8d 04 00          	lea    (%rax,%r8,1),%rax
    acc ^= val;
  4020c3:	4c 31 d0             	xor    %r10,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  4020c6:	48 0f af c1          	imul   %rcx,%rax
    h64 += (U64) len;
  4020ca:	48 01 d0             	add    %rdx,%rax
    acc += input * PRIME64_2;
  4020cd:	48 8b 55 40          	mov    0x40(%rbp),%rdx
  4020d1:	48 0f af d6          	imul   %rsi,%rdx
    acc  = XXH_rotl64(acc, 31);
  4020d5:	48 c1 c2 1f          	rol    $0x1f,%rdx
    acc *= PRIME64_1;
  4020d9:	48 0f af d1          	imul   %rcx,%rdx
        h64 ^= k1;
  4020dd:	48 31 d0             	xor    %rdx,%rax
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
  4020e0:	48 c1 c0 1b          	rol    $0x1b,%rax
  4020e4:	48 0f af c1          	imul   %rcx,%rax
  4020e8:	4c 01 c0             	add    %r8,%rax
    if (p+4<=bEnd) {
  4020eb:	4c 8d 45 4c          	lea    0x4c(%rbp),%r8
  4020ef:	4c 39 c7             	cmp    %r8,%rdi
  4020f2:	0f 83 78 04 00 00    	jae    402570 <fc_solve_check_and_add_state+0xa00>
        h64 ^= (*p) * PRIME64_5;
  4020f8:	48 be c5 67 56 16 2f 	movabs $0x27d4eb2f165667c5,%rsi
  4020ff:	eb d4 27 
        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
  402102:	48 b9 87 ca eb 85 b1 	movabs $0x9e3779b185ebca87,%rcx
  402109:	79 37 9e 
    while (p<bEnd) {
  40210c:	49 39 f9             	cmp    %rdi,%r9
  40210f:	73 2b                	jae    40213c <fc_solve_check_and_add_state+0x5cc>
  402111:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  402118:	00 00 00 00 
  40211c:	0f 1f 40 00          	nopl   0x0(%rax)
        h64 ^= (*p) * PRIME64_5;
  402120:	41 0f b6 11          	movzbl (%r9),%edx
        p++;
  402124:	49 83 c1 01          	add    $0x1,%r9
        h64 ^= (*p) * PRIME64_5;
  402128:	48 0f af d6          	imul   %rsi,%rdx
  40212c:	48 31 d0             	xor    %rdx,%rax
        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
  40212f:	48 c1 c0 0b          	rol    $0xb,%rax
  402133:	48 0f af c1          	imul   %rcx,%rax
    while (p<bEnd) {
  402137:	4c 39 cf             	cmp    %r9,%rdi
  40213a:	75 e4                	jne    402120 <fc_solve_check_and_add_state+0x5b0>
    h64 ^= h64 >> 33;
  40213c:	49 89 c6             	mov    %rax,%r14
        (hash->entries + (hash_value & (hash->size_bitmask)));
  40213f:	4c 8b 63 10          	mov    0x10(%rbx),%r12
  402143:	49 c1 ee 21          	shr    $0x21,%r14
  402147:	4c 31 f0             	xor    %r14,%rax
    h64 *= PRIME64_2;
  40214a:	49 be 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%r14
  402151:	ae b2 c2 
  402154:	4c 0f af f0          	imul   %rax,%r14
    h64 ^= h64 >> 29;
  402158:	4c 89 f0             	mov    %r14,%rax
  40215b:	48 c1 e8 1d          	shr    $0x1d,%rax
  40215f:	49 31 c6             	xor    %rax,%r14
    h64 *= PRIME64_3;
  402162:	48 b8 f9 79 37 9e b1 	movabs $0x165667b19e3779f9,%rax
  402169:	67 56 16 
  40216c:	4c 0f af f0          	imul   %rax,%r14
    h64 ^= h64 >> 32;
  402170:	4c 89 f0             	mov    %r14,%rax
  402173:	48 c1 e8 20          	shr    $0x20,%rax
  402177:	49 31 c6             	xor    %rax,%r14
  40217a:	48 63 43 20          	movslq 0x20(%rbx),%rax
  40217e:	4c 21 f0             	and    %r14,%rax
    typeof(hash->entries[0]) *const list =
  402181:	49 8d 04 c4          	lea    (%r12,%rax,8),%rax
    if (list->first_item == NULL)
  402185:	4c 8b 28             	mov    (%rax),%r13
  402188:	4d 85 ed             	test   %r13,%r13
  40218b:	0f 84 0f 04 00 00    	je     4025a0 <fc_solve_check_and_add_state+0xa30>
    const_SLOT(hash_type, hash);
  402191:	8b 43 18             	mov    0x18(%rbx),%eax
  402194:	89 44 24 0c          	mov    %eax,0xc(%rsp)
  402198:	eb 16                	jmp    4021b0 <fc_solve_check_and_add_state+0x640>
  40219a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            item = item->next;
  4021a0:	49 8b 45 10          	mov    0x10(%r13),%rax
        while (item != NULL)
  4021a4:	48 85 c0             	test   %rax,%rax
  4021a7:	0f 84 43 03 00 00    	je     4024f0 <fc_solve_check_and_add_state+0x980>
  4021ad:	49 89 c5             	mov    %rax,%r13
            if ((item->hash_value == hash_value)
  4021b0:	4d 39 75 08          	cmp    %r14,0x8(%r13)
  4021b4:	75 ea                	jne    4021a0 <fc_solve_check_and_add_state+0x630>
                && MY_HASH_COMPARE())
  4021b6:	8b 44 24 0c          	mov    0xc(%rsp),%eax
  4021ba:	4d 8b 7d 00          	mov    0x0(%r13),%r15
  4021be:	85 c0                	test   %eax,%eax
  4021c0:	0f 84 2a 02 00 00    	je     4023f0 <fc_solve_check_and_add_state+0x880>
  4021c6:	ba 48 00 00 00       	mov    $0x48,%edx
  4021cb:	48 89 ee             	mov    %rbp,%rsi
  4021ce:	4c 89 ff             	mov    %r15,%rdi
  4021d1:	e8 aa ee ff ff       	callq  401080 <memcmp@plt>
  4021d6:	85 c0                	test   %eax,%eax
  4021d8:	0f 94 c0             	sete   %al
  4021db:	84 c0                	test   %al,%al
  4021dd:	74 c1                	je     4021a0 <fc_solve_check_and_add_state+0x630>
    if (existing_void)
  4021df:	4d 85 ff             	test   %r15,%r15
  4021e2:	0f 84 52 03 00 00    	je     40253a <fc_solve_check_and_add_state+0x9ca>
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  4021e8:	49 8d 47 48          	lea    0x48(%r15),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  4021ec:	c4 c1 f9 6e cf       	vmovq  %r15,%xmm1
  4021f1:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  4021f7:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  4021fc:	c5 f8 11 00          	vmovups %xmm0,(%rax)
    }
    return HANDLE_existing_void(val);
#else
#error Unknown FCS_STATE_STORAGE. Please define it to a valid value.
#endif
}
  402200:	48 83 c4 48          	add    $0x48,%rsp
        return FALSE;
  402204:	31 c0                	xor    %eax,%eax
}
  402206:	5b                   	pop    %rbx
  402207:	5d                   	pop    %rbp
  402208:	41 5c                	pop    %r12
  40220a:	41 5d                	pop    %r13
  40220c:	41 5e                	pop    %r14
  40220e:	41 5f                	pop    %r15
  402210:	c3                   	retq   
  402211:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  402218:	00 00 00 00 
  40221c:	0f 1f 40 00          	nopl   0x0(%rax)
    char *const new_data = meta_request_new_buffer(allocator->meta);
  402220:	48 8b 93 f8 00 00 00 	mov    0xf8(%rbx),%rdx
    char *const ret = meta_alloc->recycle_bin;
  402227:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40222a:	48 85 c0             	test   %rax,%rax
  40222d:	0f 84 ed 03 00 00    	je     402620 <fc_solve_check_and_add_state+0xab0>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  402233:	48 8b 08             	mov    (%rax),%rcx
  402236:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  402239:	48 8b 93 d8 00 00 00 	mov    0xd8(%rbx),%rdx
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  402240:	48 8d 68 08          	lea    0x8(%rax),%rbp
    allocator->ptr += how_much;
  402244:	49 01 ee             	add    %rbp,%r14
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  402247:	48 89 10             	mov    %rdx,(%rax)
    allocator->old_list = new_data;
  40224a:	48 89 83 d8 00 00 00 	mov    %rax,0xd8(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  402251:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  402257:	48 89 ab f0 00 00 00 	mov    %rbp,0xf0(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40225e:	48 89 83 e0 00 00 00 	mov    %rax,0xe0(%rbx)
  402265:	4c 89 b3 e8 00 00 00 	mov    %r14,0xe8(%rbx)
        memcpy(new_ptr, column, col_len);
  40226c:	49 83 fc 08          	cmp    $0x8,%r12
  402270:	0f 82 a4 f9 ff ff    	jb     401c1a <fc_solve_check_and_add_state+0xaa>
  402276:	4a 8b 44 26 f8       	mov    -0x8(%rsi,%r12,1),%rax
  40227b:	49 8d 4c 24 ff       	lea    -0x1(%r12),%rcx
  402280:	48 89 ef             	mov    %rbp,%rdi
  402283:	48 c1 e9 03          	shr    $0x3,%rcx
  402287:	4a 89 44 25 f8       	mov    %rax,-0x8(%rbp,%r12,1)
  40228c:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40228f:	e9 a5 f9 ff ff       	jmpq   401c39 <fc_solve_check_and_add_state+0xc9>
  402294:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40229b:	00 00 00 00 
  40229f:	90                   	nop
        const int min_len = min(s1[0], s2[0]);
  4022a0:	41 0f be 3c 24       	movsbl (%r12),%edi
  4022a5:	0f b6 75 00          	movzbl 0x0(%rbp),%esi
  4022a9:	40 38 f7             	cmp    %sil,%dil
  4022ac:	40 0f be d6          	movsbl %sil,%edx
  4022b0:	0f 4e d7             	cmovle %edi,%edx
        for (int a = 1; a <= min_len; a++)
  4022b3:	85 d2                	test   %edx,%edx
  4022b5:	7e 35                	jle    4022ec <fc_solve_check_and_add_state+0x77c>
            if (ret != 0)
  4022b7:	0f b6 45 01          	movzbl 0x1(%rbp),%eax
  4022bb:	41 38 44 24 01       	cmp    %al,0x1(%r12)
  4022c0:	0f 85 0a fc ff ff    	jne    401ed0 <fc_solve_check_and_add_state+0x360>
  4022c6:	b8 02 00 00 00       	mov    $0x2,%eax
  4022cb:	eb 1b                	jmp    4022e8 <fc_solve_check_and_add_state+0x778>
  4022cd:	0f 1f 00             	nopl   (%rax)
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
  4022d0:	45 0f b6 14 04       	movzbl (%r12,%rax,1),%r10d
  4022d5:	44 0f b6 4c 05 00    	movzbl 0x0(%rbp,%rax,1),%r9d
            if (ret != 0)
  4022db:	48 83 c0 01          	add    $0x1,%rax
  4022df:	45 38 ca             	cmp    %r9b,%r10b
  4022e2:	0f 85 e8 fb ff ff    	jne    401ed0 <fc_solve_check_and_add_state+0x360>
        for (int a = 1; a <= min_len; a++)
  4022e8:	39 c2                	cmp    %eax,%edx
  4022ea:	7d e4                	jge    4022d0 <fc_solve_check_and_add_state+0x760>
    if (s1[0] < s2[0])
  4022ec:	40 38 f7             	cmp    %sil,%dil
  4022ef:	0f 8f db fb ff ff    	jg     401ed0 <fc_solve_check_and_add_state+0x360>
    {
        return -1;
    }
    else if (s1[0] > s2[0])
  4022f5:	0f 9d c0             	setge  %al
  4022f8:	e9 1e fc ff ff       	jmpq   401f1b <fc_solve_check_and_add_state+0x3ab>
  4022fd:	0f 1f 00             	nopl   (%rax)
        item_placeholder = &(list->first_item);
  402300:	49 89 c7             	mov    %rax,%r15
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  402303:	48 8b 93 98 00 00 00 	mov    0x98(%rbx),%rdx
  40230a:	48 8b 83 90 00 00 00 	mov    0x90(%rbx),%rax
  402311:	48 29 d0             	sub    %rdx,%rax
  402314:	48 83 f8 17          	cmp    $0x17,%rax
  402318:	76 66                	jbe    402380 <fc_solve_check_and_add_state+0x810>
        allocator->rollback_ptr = allocator->ptr;
  40231a:	48 89 93 a0 00 00 00 	mov    %rdx,0xa0(%rbx)
    allocator->ptr += how_much;
  402321:	48 8d 42 18          	lea    0x18(%rdx),%rax
  402325:	48 89 83 98 00 00 00 	mov    %rax,0x98(%rbx)
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  40232c:	48 8b 43 78          	mov    0x78(%rbx),%rax
    *(*(item_placeholder) = item) = (typeof(*item)){
  402330:	49 89 17             	mov    %rdx,(%r15)
  402333:	48 89 2a             	mov    %rbp,(%rdx)
  402336:	4c 89 62 08          	mov    %r12,0x8(%rdx)
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  40233a:	48 83 c0 01          	add    $0x1,%rax
    *(*(item_placeholder) = item) = (typeof(*item)){
  40233e:	48 c7 42 10 00 00 00 	movq   $0x0,0x10(%rdx)
  402345:	00 
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  402346:	48 89 43 78          	mov    %rax,0x78(%rbx)
  40234a:	48 3b 83 80 00 00 00 	cmp    0x80(%rbx),%rax
  402351:	0f 8e e6 fb ff ff    	jle    401f3d <fc_solve_check_and_add_state+0x3cd>
    const int old_size = hash->size;
  402357:	44 8b 7b 6c          	mov    0x6c(%rbx),%r15d
    const int new_size = old_size << 1;
  40235b:	43 8d 2c 3f          	lea    (%r15,%r15,1),%ebp
    if (new_size < old_size)
  40235f:	41 39 ef             	cmp    %ebp,%r15d
  402362:	0f 8e e8 00 00 00    	jle    402450 <fc_solve_check_and_add_state+0x8e0>
        hash->max_num_elems_before_resize = FCS_INT_LIMIT_MAX;
  402368:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  40236f:	ff ff 7f 
  402372:	48 89 83 80 00 00 00 	mov    %rax,0x80(%rbx)
        REPLACE_WITH_CACHED(cached_stack);
  402379:	e9 bf fb ff ff       	jmpq   401f3d <fc_solve_check_and_add_state+0x3cd>
  40237e:	66 90                	xchg   %ax,%ax
    char *const new_data = meta_request_new_buffer(allocator->meta);
  402380:	48 8b 93 a8 00 00 00 	mov    0xa8(%rbx),%rdx
    char *const ret = meta_alloc->recycle_bin;
  402387:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40238a:	48 85 c0             	test   %rax,%rax
  40238d:	0f 84 5d 03 00 00    	je     4026f0 <fc_solve_check_and_add_state+0xb80>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  402393:	48 8b 08             	mov    (%rax),%rcx
  402396:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  402399:	48 8b 93 88 00 00 00 	mov    0x88(%rbx),%rdx
  4023a0:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4023a3:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  4023a7:	48 89 83 88 00 00 00 	mov    %rax,0x88(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4023ae:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4023b4:	48 89 93 a0 00 00 00 	mov    %rdx,0xa0(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4023bb:	48 89 83 90 00 00 00 	mov    %rax,0x90(%rbx)
  4023c2:	e9 5a ff ff ff       	jmpq   402321 <fc_solve_check_and_add_state+0x7b1>
  4023c7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4023ce:	00 00 
  4023d0:	4c 89 e5             	mov    %r12,%rbp
  4023d3:	49 89 ce             	mov    %rcx,%r14
  4023d6:	49 89 dc             	mov    %rbx,%r12
        item_placeholder = &(last_item->next);
  4023d9:	49 83 c7 10          	add    $0x10,%r15
  4023dd:	4c 89 c3             	mov    %r8,%rbx
  4023e0:	e9 1e ff ff ff       	jmpq   402303 <fc_solve_check_and_add_state+0x793>
  4023e5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4023ec:	00 00 00 00 
        const int min_len = min(s1[0], s2[0]);
  4023f0:	0f be 75 00          	movsbl 0x0(%rbp),%esi
  4023f4:	41 0f b6 0f          	movzbl (%r15),%ecx
  4023f8:	40 38 ce             	cmp    %cl,%sil
  4023fb:	0f be d1             	movsbl %cl,%edx
  4023fe:	0f 4e d6             	cmovle %esi,%edx
        for (int a = 1; a <= min_len; a++)
  402401:	85 d2                	test   %edx,%edx
  402403:	7e 37                	jle    40243c <fc_solve_check_and_add_state+0x8cc>
            if (ret != 0)
  402405:	41 0f b6 47 01       	movzbl 0x1(%r15),%eax
  40240a:	38 45 01             	cmp    %al,0x1(%rbp)
  40240d:	0f 85 8d fd ff ff    	jne    4021a0 <fc_solve_check_and_add_state+0x630>
  402413:	b8 02 00 00 00       	mov    $0x2,%eax
  402418:	eb 1e                	jmp    402438 <fc_solve_check_and_add_state+0x8c8>
  40241a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
  402420:	44 0f b6 44 05 00    	movzbl 0x0(%rbp,%rax,1),%r8d
  402426:	41 0f b6 3c 07       	movzbl (%r15,%rax,1),%edi
            if (ret != 0)
  40242b:	48 83 c0 01          	add    $0x1,%rax
  40242f:	41 38 f8             	cmp    %dil,%r8b
  402432:	0f 85 68 fd ff ff    	jne    4021a0 <fc_solve_check_and_add_state+0x630>
        for (int a = 1; a <= min_len; a++)
  402438:	39 c2                	cmp    %eax,%edx
  40243a:	7d e4                	jge    402420 <fc_solve_check_and_add_state+0x8b0>
    if (s1[0] < s2[0])
  40243c:	40 38 ce             	cmp    %cl,%sil
  40243f:	0f 8f 5b fd ff ff    	jg     4021a0 <fc_solve_check_and_add_state+0x630>
    else if (s1[0] > s2[0])
  402445:	0f 9d c0             	setge  %al
  402448:	e9 8e fd ff ff       	jmpq   4021db <fc_solve_check_and_add_state+0x66b>
  40244d:	0f 1f 00             	nopl   (%rax)
    const int new_size_bitmask = new_size - 1;
  402450:	44 8d 65 ff          	lea    -0x1(%rbp),%r12d
        calloc(new_size, sizeof(new_entries[0]));
  402454:	48 63 c5             	movslq %ebp,%rax
  402457:	be 08 00 00 00       	mov    $0x8,%esi
  40245c:	48 89 c7             	mov    %rax,%rdi
  40245f:	48 89 44 24 28       	mov    %rax,0x28(%rsp)
  402464:	e8 97 ec ff ff       	callq  401100 <calloc@plt>
    for (int i = 0; i < old_size; i++)
  402469:	45 85 ff             	test   %r15d,%r15d
  40246c:	7e 4e                	jle    4024bc <fc_solve_check_and_add_state+0x94c>
  40246e:	41 8d 57 ff          	lea    -0x1(%r15),%edx
  402472:	4c 89 f6             	mov    %r14,%rsi
  402475:	4d 8d 4c d6 08       	lea    0x8(%r14,%rdx,8),%r9
  40247a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        hash_item *item = entries[i].first_item;
  402480:	48 8b 16             	mov    (%rsi),%rdx
        while (item != NULL)
  402483:	48 85 d2             	test   %rdx,%rdx
  402486:	74 2b                	je     4024b3 <fc_solve_check_and_add_state+0x943>
  402488:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40248f:	00 
            const int place = item->hash_value & new_size_bitmask;
  402490:	8b 4a 08             	mov    0x8(%rdx),%ecx
            hash_item *const next_item = item->next;
  402493:	48 8b 7a 10          	mov    0x10(%rdx),%rdi
            const int place = item->hash_value & new_size_bitmask;
  402497:	44 21 e1             	and    %r12d,%ecx
            item->next = new_entries[place].first_item;
  40249a:	48 63 c9             	movslq %ecx,%rcx
  40249d:	48 8d 0c c8          	lea    (%rax,%rcx,8),%rcx
  4024a1:	4c 8b 01             	mov    (%rcx),%r8
  4024a4:	4c 89 42 10          	mov    %r8,0x10(%rdx)
            new_entries[place].first_item = item;
  4024a8:	48 89 11             	mov    %rdx,(%rcx)
            item = next_item;
  4024ab:	48 89 fa             	mov    %rdi,%rdx
        while (item != NULL)
  4024ae:	48 85 ff             	test   %rdi,%rdi
  4024b1:	75 dd                	jne    402490 <fc_solve_check_and_add_state+0x920>
  4024b3:	48 83 c6 08          	add    $0x8,%rsi
    for (int i = 0; i < old_size; i++)
  4024b7:	49 39 f1             	cmp    %rsi,%r9
  4024ba:	75 c4                	jne    402480 <fc_solve_check_and_add_state+0x910>
    free(hash->entries);
  4024bc:	4c 89 f7             	mov    %r14,%rdi
  4024bf:	48 89 44 24 30       	mov    %rax,0x30(%rsp)
  4024c4:	e8 87 eb ff ff       	callq  401050 <free@plt>
    hash->size = new_size;
  4024c9:	89 6b 6c             	mov    %ebp,0x6c(%rbx)
    hash->max_num_elems_before_resize = (new_size << 1);
  4024cc:	48 8b 6c 24 28       	mov    0x28(%rsp),%rbp
    hash->entries = new_entries;
  4024d1:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
    hash->size_bitmask = new_size_bitmask;
  4024d6:	44 89 63 70          	mov    %r12d,0x70(%rbx)
  4024da:	48 01 ed             	add    %rbp,%rbp
    hash->entries = new_entries;
  4024dd:	48 89 43 60          	mov    %rax,0x60(%rbx)
  4024e1:	48 89 ab 80 00 00 00 	mov    %rbp,0x80(%rbx)
        REPLACE_WITH_CACHED(cached_stack);
  4024e8:	e9 50 fa ff ff       	jmpq   401f3d <fc_solve_check_and_add_state+0x3cd>
  4024ed:	0f 1f 00             	nopl   (%rax)
        item_placeholder = &(last_item->next);
  4024f0:	49 83 c5 10          	add    $0x10,%r13
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  4024f4:	48 8b 53 48          	mov    0x48(%rbx),%rdx
  4024f8:	48 8b 43 40          	mov    0x40(%rbx),%rax
  4024fc:	48 29 d0             	sub    %rdx,%rax
  4024ff:	48 83 f8 17          	cmp    $0x17,%rax
  402503:	0f 86 d7 00 00 00    	jbe    4025e0 <fc_solve_check_and_add_state+0xa70>
        allocator->rollback_ptr = allocator->ptr;
  402509:	48 89 53 50          	mov    %rdx,0x50(%rbx)
    allocator->ptr += how_much;
  40250d:	48 8d 42 18          	lea    0x18(%rdx),%rax
  402511:	48 89 43 48          	mov    %rax,0x48(%rbx)
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  402515:	48 8b 43 28          	mov    0x28(%rbx),%rax
    *(*(item_placeholder) = item) = (typeof(*item)){
  402519:	49 89 55 00          	mov    %rdx,0x0(%r13)
  40251d:	48 89 2a             	mov    %rbp,(%rdx)
  402520:	4c 89 72 08          	mov    %r14,0x8(%rdx)
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  402524:	48 83 c0 01          	add    $0x1,%rax
    *(*(item_placeholder) = item) = (typeof(*item)){
  402528:	48 c7 42 10 00 00 00 	movq   $0x0,0x10(%rdx)
  40252f:	00 
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  402530:	48 89 43 28          	mov    %rax,0x28(%rbx)
  402534:	48 3b 43 30          	cmp    0x30(%rbx),%rax
  402538:	7f 76                	jg     4025b0 <fc_solve_check_and_add_state+0xa40>
        upon_new_state(instance, hard_thread, new_state->val);
  40253a:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  40253f:	48 8b 40 08          	mov    0x8(%rax),%rax
  402543:	48 8b 00             	mov    (%rax),%rax
    if (likely(parent_state))
  402546:	48 85 c0             	test   %rax,%rax
  402549:	0f 84 d1 01 00 00    	je     402720 <fc_solve_check_and_add_state+0xbb0>
        (FCS_S_NUM_ACTIVE_CHILDREN(parent_state))++;
  40254f:	66 83 40 54 01       	addw   $0x1,0x54(%rax)
  402554:	b8 01 00 00 00       	mov    $0x1,%eax
}
  402559:	48 83 c4 48          	add    $0x48,%rsp
  40255d:	5b                   	pop    %rbx
  40255e:	5d                   	pop    %rbp
  40255f:	41 5c                	pop    %r12
  402561:	41 5d                	pop    %r13
  402563:	41 5e                	pop    %r14
  402565:	41 5f                	pop    %r15
  402567:	c3                   	retq   
  402568:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40256f:	00 
        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
  402570:	8b 55 48             	mov    0x48(%rbp),%edx
        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
  402573:	4d 89 c1             	mov    %r8,%r9
        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
  402576:	48 0f af ca          	imul   %rdx,%rcx
  40257a:	48 31 c8             	xor    %rcx,%rax
        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
  40257d:	48 c1 c0 17          	rol    $0x17,%rax
  402581:	48 0f af f0          	imul   %rax,%rsi
  402585:	48 b8 f9 79 37 9e b1 	movabs $0x165667b19e3779f9,%rax
  40258c:	67 56 16 
  40258f:	48 01 f0             	add    %rsi,%rax
  402592:	e9 61 fb ff ff       	jmpq   4020f8 <fc_solve_check_and_add_state+0x588>
  402597:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40259e:	00 00 
        item_placeholder = &(list->first_item);
  4025a0:	49 89 c5             	mov    %rax,%r13
  4025a3:	e9 4c ff ff ff       	jmpq   4024f4 <fc_solve_check_and_add_state+0x984>
  4025a8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4025af:	00 
    const int old_size = hash->size;
  4025b0:	8b 53 1c             	mov    0x1c(%rbx),%edx
    const int new_size = old_size << 1;
  4025b3:	44 8d 34 12          	lea    (%rdx,%rdx,1),%r14d
    if (new_size < old_size)
  4025b7:	44 39 f2             	cmp    %r14d,%edx
  4025ba:	0f 8e a0 00 00 00    	jle    402660 <fc_solve_check_and_add_state+0xaf0>
        hash->max_num_elems_before_resize = FCS_INT_LIMIT_MAX;
  4025c0:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  4025c7:	ff ff 7f 
  4025ca:	48 89 43 30          	mov    %rax,0x30(%rbx)
    if (existing_void)
  4025ce:	e9 67 ff ff ff       	jmpq   40253a <fc_solve_check_and_add_state+0x9ca>
  4025d3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4025da:	00 00 00 00 
  4025de:	66 90                	xchg   %ax,%ax
    char *const new_data = meta_request_new_buffer(allocator->meta);
  4025e0:	48 8b 53 58          	mov    0x58(%rbx),%rdx
    char *const ret = meta_alloc->recycle_bin;
  4025e4:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  4025e7:	48 85 c0             	test   %rax,%rax
  4025ea:	0f 84 40 01 00 00    	je     402730 <fc_solve_check_and_add_state+0xbc0>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  4025f0:	48 8b 08             	mov    (%rax),%rcx
  4025f3:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  4025f6:	48 8b 53 38          	mov    0x38(%rbx),%rdx
  4025fa:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4025fd:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  402601:	48 89 43 38          	mov    %rax,0x38(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  402605:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40260b:	48 89 53 50          	mov    %rdx,0x50(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40260f:	48 89 43 40          	mov    %rax,0x40(%rbx)
  402613:	e9 f5 fe ff ff       	jmpq   40250d <fc_solve_check_and_add_state+0x99d>
  402618:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40261f:	00 
        return malloc(ALLOCED_SIZE);
  402620:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  402625:	48 89 74 24 28       	mov    %rsi,0x28(%rsp)
  40262a:	e8 c1 ea ff ff       	callq  4010f0 <malloc@plt>
  40262f:	48 8b 74 24 28       	mov    0x28(%rsp),%rsi
  402634:	e9 00 fc ff ff       	jmpq   402239 <fc_solve_check_and_add_state+0x6c9>
  402639:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        memcpy(new_ptr, column, col_len);
  402640:	8b 06                	mov    (%rsi),%eax
  402642:	89 45 00             	mov    %eax,0x0(%rbp)
  402645:	42 8b 44 26 fc       	mov    -0x4(%rsi,%r12,1),%eax
  40264a:	42 89 44 25 fc       	mov    %eax,-0x4(%rbp,%r12,1)
  40264f:	e9 e5 f5 ff ff       	jmpq   401c39 <fc_solve_check_and_add_state+0xc9>
  402654:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40265b:	00 00 00 00 
  40265f:	90                   	nop
  402660:	89 54 24 0c          	mov    %edx,0xc(%rsp)
    const int new_size_bitmask = new_size - 1;
  402664:	45 8d 6e ff          	lea    -0x1(%r14),%r13d
        calloc(new_size, sizeof(new_entries[0]));
  402668:	49 63 ee             	movslq %r14d,%rbp
  40266b:	be 08 00 00 00       	mov    $0x8,%esi
  402670:	48 89 ef             	mov    %rbp,%rdi
  402673:	e8 88 ea ff ff       	callq  401100 <calloc@plt>
    for (int i = 0; i < old_size; i++)
  402678:	8b 54 24 0c          	mov    0xc(%rsp),%edx
        calloc(new_size, sizeof(new_entries[0]));
  40267c:	49 89 c7             	mov    %rax,%r15
    for (int i = 0; i < old_size; i++)
  40267f:	85 d2                	test   %edx,%edx
  402681:	7e 49                	jle    4026cc <fc_solve_check_and_add_state+0xb5c>
  402683:	8d 42 ff             	lea    -0x1(%rdx),%eax
  402686:	4d 89 e0             	mov    %r12,%r8
  402689:	49 8d 44 c4 08       	lea    0x8(%r12,%rax,8),%rax
  40268e:	66 90                	xchg   %ax,%ax
        hash_item *item = entries[i].first_item;
  402690:	49 8b 10             	mov    (%r8),%rdx
        while (item != NULL)
  402693:	48 85 d2             	test   %rdx,%rdx
  402696:	74 2b                	je     4026c3 <fc_solve_check_and_add_state+0xb53>
  402698:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40269f:	00 
            const int place = item->hash_value & new_size_bitmask;
  4026a0:	8b 4a 08             	mov    0x8(%rdx),%ecx
            hash_item *const next_item = item->next;
  4026a3:	48 8b 72 10          	mov    0x10(%rdx),%rsi
            const int place = item->hash_value & new_size_bitmask;
  4026a7:	44 21 e9             	and    %r13d,%ecx
            item->next = new_entries[place].first_item;
  4026aa:	48 63 c9             	movslq %ecx,%rcx
  4026ad:	49 8d 0c cf          	lea    (%r15,%rcx,8),%rcx
  4026b1:	48 8b 39             	mov    (%rcx),%rdi
  4026b4:	48 89 7a 10          	mov    %rdi,0x10(%rdx)
            new_entries[place].first_item = item;
  4026b8:	48 89 11             	mov    %rdx,(%rcx)
            item = next_item;
  4026bb:	48 89 f2             	mov    %rsi,%rdx
        while (item != NULL)
  4026be:	48 85 f6             	test   %rsi,%rsi
  4026c1:	75 dd                	jne    4026a0 <fc_solve_check_and_add_state+0xb30>
  4026c3:	49 83 c0 08          	add    $0x8,%r8
    for (int i = 0; i < old_size; i++)
  4026c7:	49 39 c0             	cmp    %rax,%r8
  4026ca:	75 c4                	jne    402690 <fc_solve_check_and_add_state+0xb20>
    free(hash->entries);
  4026cc:	4c 89 e7             	mov    %r12,%rdi
  4026cf:	48 01 ed             	add    %rbp,%rbp
  4026d2:	e8 79 e9 ff ff       	callq  401050 <free@plt>
    hash->entries = new_entries;
  4026d7:	4c 89 7b 10          	mov    %r15,0x10(%rbx)
    hash->size = new_size;
  4026db:	44 89 73 1c          	mov    %r14d,0x1c(%rbx)
    hash->size_bitmask = new_size_bitmask;
  4026df:	44 89 6b 20          	mov    %r13d,0x20(%rbx)
  4026e3:	48 89 6b 30          	mov    %rbp,0x30(%rbx)
    if (existing_void)
  4026e7:	e9 4e fe ff ff       	jmpq   40253a <fc_solve_check_and_add_state+0x9ca>
  4026ec:	0f 1f 40 00          	nopl   0x0(%rax)
  4026f0:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  4026f5:	e8 f6 e9 ff ff       	callq  4010f0 <malloc@plt>
  4026fa:	e9 9a fc ff ff       	jmpq   402399 <fc_solve_check_and_add_state+0x829>
  4026ff:	90                   	nop
        memcpy(new_ptr, column, col_len);
  402700:	42 0f b7 44 26 fe    	movzwl -0x2(%rsi,%r12,1),%eax
  402706:	66 42 89 44 25 fe    	mov    %ax,-0x2(%rbp,%r12,1)
  40270c:	e9 28 f5 ff ff       	jmpq   401c39 <fc_solve_check_and_add_state+0xc9>
  402711:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  402718:	00 00 00 00 
  40271c:	0f 1f 40 00          	nopl   0x0(%rax)
    if (likely(parent_state))
  402720:	b8 01 00 00 00       	mov    $0x1,%eax
  402725:	e9 2f fe ff ff       	jmpq   402559 <fc_solve_check_and_add_state+0x9e9>
  40272a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  402730:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  402735:	e8 b6 e9 ff ff       	callq  4010f0 <malloc@plt>
  40273a:	e9 b7 fe ff ff       	jmpq   4025f6 <fc_solve_check_and_add_state+0xa86>
  40273f:	90                   	nop

0000000000402740 <fc_solve_sfs_raymond_prune>:
    return -1;
}

extern fcs_collectible_state *fc_solve_sfs_raymond_prune(
    fcs_soft_thread *const soft_thread, fcs_kv_state raw_state_raw)
{
  402740:	41 57                	push   %r15
  402742:	48 89 d1             	mov    %rdx,%rcx
  402745:	49 89 ff             	mov    %rdi,%r15
#define EMPTY
    tests_define_accessors__generic(EMPTY);
    STACKS__SET_PARAMS();

    sfs_check_state_begin();
  402748:	48 89 f2             	mov    %rsi,%rdx
{
  40274b:	41 56                	push   %r14
  40274d:	41 55                	push   %r13
  40274f:	41 54                	push   %r12
    bool cards_were_moved = FALSE;
  402751:	45 31 e4             	xor    %r12d,%r12d
{
  402754:	55                   	push   %rbp
  402755:	53                   	push   %rbx
  402756:	48 83 ec 38          	sub    $0x38,%rsp
    tests_define_accessors__generic(EMPTY);
  40275a:	48 8b 1f             	mov    (%rdi),%rbx
    sfs_check_state_begin();
  40275d:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
  402762:	48 8d ab 00 01 00 00 	lea    0x100(%rbx),%rbp
  402769:	48 89 df             	mov    %rbx,%rdi
  40276c:	e8 af f2 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
    bool cards_were_moved = FALSE;
  402771:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
  402776:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40277d:	00 00 00 
  402780:	31 c0                	xor    %eax,%eax
    bool num_cards_moved;
    do
    {
        num_cards_moved = FALSE;
  402782:	45 31 d2             	xor    %r10d,%r10d
  402785:	eb 17                	jmp    40279e <fc_solve_sfs_raymond_prune+0x5e>
  402787:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40278e:	00 00 

            my_copy_stack(stack_idx);
            fcs_state_pop_col_top(&new_state_key, stack_idx);
            fcs_increment_foundation(new_state_key, dest_foundation);
            fcs_move_stack_non_seq_push(moves,
                FCS_MOVE_TYPE_STACK_TO_FOUNDATION, stack_idx, dest_foundation);
  402790:	48 83 c0 01          	add    $0x1,%rax
        for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  402794:	48 83 f8 08          	cmp    $0x8,%rax
  402798:	0f 84 f5 00 00 00    	je     402893 <fc_solve_sfs_raymond_prune+0x153>
            const_AUTO(col, fcs_state_get_col(new_state_key, stack_idx));
  40279e:	48 63 d0             	movslq %eax,%rdx
  4027a1:	4c 63 c0             	movslq %eax,%r8
  4027a4:	48 8b 34 d1          	mov    (%rcx,%rdx,8),%rsi
            const int cards_num = fcs_col_len(col);
  4027a8:	0f be 3e             	movsbl (%rsi),%edi
  4027ab:	89 fa                	mov    %edi,%edx
            if (!cards_num)
  4027ad:	85 ff                	test   %edi,%edi
  4027af:	74 df                	je     402790 <fc_solve_sfs_raymond_prune+0x50>
            const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  4027b1:	83 ef 01             	sub    $0x1,%edi
  4027b4:	48 63 ff             	movslq %edi,%rdi
  4027b7:	0f b6 7c 3e 01       	movzbl 0x1(%rsi,%rdi,1),%edi
    const int_fast32_t suit = fcs_card_suit(card);
  4027bc:	49 89 f9             	mov    %rdi,%r9
    const int_fast32_t rank = fcs_card_rank(card);
  4027bf:	41 89 fd             	mov    %edi,%r13d
    const int_fast32_t suit = fcs_card_suit(card);
  4027c2:	41 83 e1 03          	and    $0x3,%r9d
    const int_fast32_t rank = fcs_card_rank(card);
  4027c6:	41 c0 fd 02          	sar    $0x2,%r13b
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  4027ca:	4e 0f be 74 09 44    	movsbq 0x44(%rcx,%r9,1),%r14
    const int_fast32_t rank = fcs_card_rank(card);
  4027d0:	4d 0f be ed          	movsbq %r13b,%r13
    const int_fast32_t rank_min_2 = rank - 2;
  4027d4:	4d 8d 5d fe          	lea    -0x2(%r13),%r11
    const int_fast32_t rank_min_1 = rank - 1;
  4027d8:	49 83 ed 01          	sub    $0x1,%r13
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  4027dc:	4d 39 f5             	cmp    %r14,%r13
  4027df:	75 af                	jne    402790 <fc_solve_sfs_raymond_prune+0x50>
                if (fcs_foundation_value(*ptr_state, f) <
  4027e1:	41 89 fd             	mov    %edi,%r13d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4027e4:	41 89 fe             	mov    %edi,%r14d
  4027e7:	41 83 e5 01          	and    $0x1,%r13d
  4027eb:	41 f7 d6             	not    %r14d
  4027ee:	41 83 e6 01          	and    $0x1,%r14d
  4027f2:	44 88 6c 24 0f       	mov    %r13b,0xf(%rsp)
                    rank_min_2 -
  4027f7:	4d 89 dd             	mov    %r11,%r13
  4027fa:	4d 29 f5             	sub    %r14,%r13
                if (fcs_foundation_value(*ptr_state, f) <
  4027fd:	4c 0f be 71 44       	movsbq 0x44(%rcx),%r14
  402802:	4d 39 f5             	cmp    %r14,%r13
  402805:	7f 89                	jg     402790 <fc_solve_sfs_raymond_prune+0x50>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402807:	4c 0f be 6c 24 0f    	movsbq 0xf(%rsp),%r13
                    rank_min_2 -
  40280d:	4d 89 de             	mov    %r11,%r14
  402810:	4d 29 ee             	sub    %r13,%r14
                if (fcs_foundation_value(*ptr_state, f) <
  402813:	4c 0f be 69 45       	movsbq 0x45(%rcx),%r13
  402818:	4d 39 ee             	cmp    %r13,%r14
  40281b:	0f 8f 6f ff ff ff    	jg     402790 <fc_solve_sfs_raymond_prune+0x50>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402821:	41 89 fd             	mov    %edi,%r13d
                    rank_min_2 -
  402824:	4d 89 de             	mov    %r11,%r14
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402827:	41 83 f5 fd          	xor    $0xfffffffd,%r13d
  40282b:	41 83 e5 01          	and    $0x1,%r13d
                    rank_min_2 -
  40282f:	4d 29 ee             	sub    %r13,%r14
                if (fcs_foundation_value(*ptr_state, f) <
  402832:	4c 0f be 69 46       	movsbq 0x46(%rcx),%r13
  402837:	4d 39 ee             	cmp    %r13,%r14
  40283a:	0f 8f 50 ff ff ff    	jg     402790 <fc_solve_sfs_raymond_prune+0x50>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402840:	83 e7 01             	and    $0x1,%edi
                    rank_min_2 -
  402843:	49 29 fb             	sub    %rdi,%r11
                if (fcs_foundation_value(*ptr_state, f) <
  402846:	48 0f be 79 47       	movsbq 0x47(%rcx),%rdi
  40284b:	49 39 fb             	cmp    %rdi,%r11
  40284e:	0f 8f 3c ff ff ff    	jg     402790 <fc_solve_sfs_raymond_prune+0x50>
            my_copy_stack(stack_idx);
  402854:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  402859:	8b 4f 14             	mov    0x14(%rdi),%ecx
  40285c:	44 0f a3 c1          	bt     %r8d,%ecx
  402860:	0f 83 aa 00 00 00    	jae    402910 <fc_solve_sfs_raymond_prune+0x1d0>

static inline void fcs_state_pop_col_top(
    fcs_state *const state, const int col_idx)
{
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
    fcs_col_pop_top(col);
  402866:	83 ea 01             	sub    $0x1,%edx
  402869:	48 83 c0 01          	add    $0x1,%rax
            num_cards_moved = TRUE;
  40286d:	41 ba 01 00 00 00    	mov    $0x1,%r10d
  402873:	88 16                	mov    %dl,(%rsi)
  402875:	48 0f be d2          	movsbq %dl,%rdx
  402879:	c6 44 16 01 00       	movb   $0x0,0x1(%rsi,%rdx,1)
            fcs_increment_foundation(new_state_key, dest_foundation);
  40287e:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
  402883:	42 80 44 09 44 01    	addb   $0x1,0x44(%rcx,%r9,1)
        for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  402889:	48 83 f8 08          	cmp    $0x8,%rax
  40288d:	0f 85 0b ff ff ff    	jne    40279e <fc_solve_sfs_raymond_prune+0x5e>

#if MAX_NUM_FREECELLS > 0
        /* Now check the same for the free cells */
        for (int fc = 0; fc < LOCAL_FREECELLS_NUM; fc++)
        {
            const fcs_card card = fcs_freecell_card(new_state_key, fc);
  402893:	0f b6 41 40          	movzbl 0x40(%rcx),%eax
            if (fcs_card_is_empty(card))
  402897:	84 c0                	test   %al,%al
  402899:	0f 85 e1 02 00 00    	jne    402b80 <fc_solve_sfs_raymond_prune+0x440>
            const fcs_card card = fcs_freecell_card(new_state_key, fc);
  40289f:	0f b6 41 41          	movzbl 0x41(%rcx),%eax
            if (fcs_card_is_empty(card))
  4028a3:	84 c0                	test   %al,%al
  4028a5:	0f 85 25 02 00 00    	jne    402ad0 <fc_solve_sfs_raymond_prune+0x390>
            const fcs_card card = fcs_freecell_card(new_state_key, fc);
  4028ab:	0f b6 41 42          	movzbl 0x42(%rcx),%eax
            if (fcs_card_is_empty(card))
  4028af:	84 c0                	test   %al,%al
  4028b1:	0f 85 b9 00 00 00    	jne    402970 <fc_solve_sfs_raymond_prune+0x230>
            const fcs_card card = fcs_freecell_card(new_state_key, fc);
  4028b7:	0f b6 41 43          	movzbl 0x43(%rcx),%eax
            if (fcs_card_is_empty(card))
  4028bb:	84 c0                	test   %al,%al
  4028bd:	0f 85 5e 01 00 00    	jne    402a21 <fc_solve_sfs_raymond_prune+0x2e1>
            fcs_increment_foundation(new_state_key, dest_foundation);
            fcs_move_stack_non_seq_push(moves,
                FCS_MOVE_TYPE_FREECELL_TO_FOUNDATION, fc, dest_foundation);
        }
#endif
        if (num_cards_moved)
  4028c3:	45 84 d2             	test   %r10b,%r10b
  4028c6:	0f 85 f7 01 00 00    	jne    402ac3 <fc_solve_sfs_raymond_prune+0x383>
        {
            cards_were_moved = TRUE;
        }
    } while (num_cards_moved);

    if (!cards_were_moved)
  4028cc:	45 84 e4             	test   %r12b,%r12b
  4028cf:	0f 84 99 03 00 00    	je     402c6e <fc_solve_sfs_raymond_prune+0x52e>
    fcs_kv_state raw_state_raw,
#endif
    fcs_kv_state *const raw_ptr_new_state_raw FCS__pass_moves(
        fcs_move_stack *const moves GCC_UNUSED))
{
    const_SLOT(hard_thread, soft_thread);
  4028d5:	49 8b 1f             	mov    (%r15),%rbx
#endif
    fcs_kv_state existing_state;

#define ptr_new_state_foo (raw_ptr_new_state_raw->val)

    if (!fc_solve_check_and_add_state(
  4028d8:	48 8d 54 24 20       	lea    0x20(%rsp),%rdx
  4028dd:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
  4028e2:	48 89 df             	mov    %rbx,%rdi
  4028e5:	e8 86 f2 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  4028ea:	84 c0                	test   %al,%al
  4028ec:	0f 84 5b 03 00 00    	je     402c4d <fc_solve_sfs_raymond_prune+0x50d>
#endif
        return FCS_STATE_kv_to_collectible(&existing_state);
    }
    else
    {
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  4028f2:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
     * Set the GENERATED_BY_PRUNING flag uncondtionally. It won't
     * hurt if it's already there, and if it's a state that was
     * found by other means, we still shouldn't prune it, because
     * it is already "prune-perfect".
     * */
    FCS_S_VISITED(ptr_next_state) |= FCS_VISITED_GENERATED_BY_PRUNING;
  4028f7:	80 48 56 10          	orb    $0x10,0x56(%rax)
    return ptr_next_state;
}
  4028fb:	48 83 c4 38          	add    $0x38,%rsp
  4028ff:	5b                   	pop    %rbx
  402900:	5d                   	pop    %rbp
  402901:	41 5c                	pop    %r12
  402903:	41 5d                	pop    %r13
  402905:	41 5e                	pop    %r14
  402907:	41 5f                	pop    %r15
  402909:	c3                   	retq   
  40290a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            my_copy_stack(stack_idx);
  402910:	44 0f ab c1          	bts    %r8d,%ecx
  402914:	48 89 c2             	mov    %rax,%rdx
  402917:	89 4f 14             	mov    %ecx,0x14(%rdi)
  40291a:	0f be 0e             	movsbl (%rsi),%ecx
  40291d:	48 c1 e2 07          	shl    $0x7,%rdx
  402921:	4c 8d 54 15 00       	lea    0x0(%rbp,%rdx,1),%r10
  402926:	83 c1 01             	add    $0x1,%ecx
  402929:	48 63 c9             	movslq %ecx,%rcx
  40292c:	48 83 f9 08          	cmp    $0x8,%rcx
  402930:	0f 83 fa 02 00 00    	jae    402c30 <fc_solve_sfs_raymond_prune+0x4f0>
  402936:	f6 c1 04             	test   $0x4,%cl
  402939:	0f 85 40 03 00 00    	jne    402c7f <fc_solve_sfs_raymond_prune+0x53f>
  40293f:	48 85 c9             	test   %rcx,%rcx
  402942:	74 0f                	je     402953 <fc_solve_sfs_raymond_prune+0x213>
  402944:	0f b6 3e             	movzbl (%rsi),%edi
  402947:	41 88 3a             	mov    %dil,(%r10)
  40294a:	f6 c1 02             	test   $0x2,%cl
  40294d:	0f 85 5c 03 00 00    	jne    402caf <fc_solve_sfs_raymond_prune+0x56f>
  402953:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
  402958:	4c 89 d6             	mov    %r10,%rsi
  40295b:	4e 89 14 c1          	mov    %r10,(%rcx,%r8,8)
  40295f:	0f b6 94 13 00 01 00 	movzbl 0x100(%rbx,%rdx,1),%edx
  402966:	00 
  402967:	e9 fa fe ff ff       	jmpq   402866 <fc_solve_sfs_raymond_prune+0x126>
  40296c:	0f 1f 40 00          	nopl   0x0(%rax)
    const int_fast32_t suit = fcs_card_suit(card);
  402970:	48 89 c7             	mov    %rax,%rdi
    const int_fast32_t rank = fcs_card_rank(card);
  402973:	89 c2                	mov    %eax,%edx
    const int_fast32_t suit = fcs_card_suit(card);
  402975:	83 e7 03             	and    $0x3,%edi
    const int_fast32_t rank = fcs_card_rank(card);
  402978:	c0 fa 02             	sar    $0x2,%dl
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  40297b:	4c 0f be 44 39 44    	movsbq 0x44(%rcx,%rdi,1),%r8
    const int_fast32_t rank = fcs_card_rank(card);
  402981:	48 0f be d2          	movsbq %dl,%rdx
    const int_fast32_t rank_min_2 = rank - 2;
  402985:	4c 8d 4a fe          	lea    -0x2(%rdx),%r9
    const int_fast32_t rank_min_1 = rank - 1;
  402989:	48 83 ea 01          	sub    $0x1,%rdx
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  40298d:	4c 89 c6             	mov    %r8,%rsi
  402990:	4c 39 c2             	cmp    %r8,%rdx
  402993:	0f 85 1e ff ff ff    	jne    4028b7 <fc_solve_sfs_raymond_prune+0x177>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402999:	89 c2                	mov    %eax,%edx
                if (fcs_foundation_value(*ptr_state, f) <
  40299b:	4c 0f be 59 44       	movsbq 0x44(%rcx),%r11
                    rank_min_2 -
  4029a0:	4d 89 ce             	mov    %r9,%r14
  4029a3:	41 89 c0             	mov    %eax,%r8d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4029a6:	f7 d2                	not    %edx
  4029a8:	41 83 e0 01          	and    $0x1,%r8d
  4029ac:	83 e2 01             	and    $0x1,%edx
                    rank_min_2 -
  4029af:	49 29 d6             	sub    %rdx,%r14
                if (fcs_foundation_value(*ptr_state, f) <
  4029b2:	4d 39 f3             	cmp    %r14,%r11
  4029b5:	0f 8c fc fe ff ff    	jl     4028b7 <fc_solve_sfs_raymond_prune+0x177>
  4029bb:	4c 0f be 59 45       	movsbq 0x45(%rcx),%r11
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4029c0:	4d 0f be c0          	movsbq %r8b,%r8
                    rank_min_2 -
  4029c4:	4c 89 ca             	mov    %r9,%rdx
  4029c7:	4c 29 c2             	sub    %r8,%rdx
                if (fcs_foundation_value(*ptr_state, f) <
  4029ca:	49 39 d3             	cmp    %rdx,%r11
  4029cd:	0f 8c e4 fe ff ff    	jl     4028b7 <fc_solve_sfs_raymond_prune+0x177>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4029d3:	89 c2                	mov    %eax,%edx
                if (fcs_foundation_value(*ptr_state, f) <
  4029d5:	4c 0f be 41 46       	movsbq 0x46(%rcx),%r8
                    rank_min_2 -
  4029da:	4d 89 cb             	mov    %r9,%r11
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4029dd:	83 f2 fd             	xor    $0xfffffffd,%edx
  4029e0:	83 e2 01             	and    $0x1,%edx
                    rank_min_2 -
  4029e3:	49 29 d3             	sub    %rdx,%r11
                if (fcs_foundation_value(*ptr_state, f) <
  4029e6:	4d 39 d8             	cmp    %r11,%r8
  4029e9:	0f 8c c8 fe ff ff    	jl     4028b7 <fc_solve_sfs_raymond_prune+0x177>
  4029ef:	48 0f be 51 47       	movsbq 0x47(%rcx),%rdx
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4029f4:	83 e0 01             	and    $0x1,%eax
                    rank_min_2 -
  4029f7:	49 29 c1             	sub    %rax,%r9
                if (fcs_foundation_value(*ptr_state, f) <
  4029fa:	4c 39 ca             	cmp    %r9,%rdx
  4029fd:	0f 8c b4 fe ff ff    	jl     4028b7 <fc_solve_sfs_raymond_prune+0x177>
            fcs_increment_foundation(new_state_key, dest_foundation);
  402a03:	83 c6 01             	add    $0x1,%esi
            fcs_empty_freecell(new_state_key, fc);
  402a06:	c6 41 42 00          	movb   $0x0,0x42(%rcx)
            num_cards_moved = TRUE;
  402a0a:	41 ba 01 00 00 00    	mov    $0x1,%r10d
            fcs_increment_foundation(new_state_key, dest_foundation);
  402a10:	40 88 74 39 44       	mov    %sil,0x44(%rcx,%rdi,1)
            const fcs_card card = fcs_freecell_card(new_state_key, fc);
  402a15:	0f b6 41 43          	movzbl 0x43(%rcx),%eax
            if (fcs_card_is_empty(card))
  402a19:	84 c0                	test   %al,%al
  402a1b:	0f 84 a2 00 00 00    	je     402ac3 <fc_solve_sfs_raymond_prune+0x383>
    const int_fast32_t suit = fcs_card_suit(card);
  402a21:	48 89 c7             	mov    %rax,%rdi
    const int_fast32_t rank = fcs_card_rank(card);
  402a24:	89 c2                	mov    %eax,%edx
    const int_fast32_t suit = fcs_card_suit(card);
  402a26:	83 e7 03             	and    $0x3,%edi
    const int_fast32_t rank = fcs_card_rank(card);
  402a29:	c0 fa 02             	sar    $0x2,%dl
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402a2c:	4c 0f be 44 39 44    	movsbq 0x44(%rcx,%rdi,1),%r8
    const int_fast32_t rank = fcs_card_rank(card);
  402a32:	48 0f be d2          	movsbq %dl,%rdx
    const int_fast32_t rank_min_2 = rank - 2;
  402a36:	4c 8d 4a fe          	lea    -0x2(%rdx),%r9
    const int_fast32_t rank_min_1 = rank - 1;
  402a3a:	48 83 ea 01          	sub    $0x1,%rdx
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402a3e:	4c 89 c6             	mov    %r8,%rsi
  402a41:	4c 39 c2             	cmp    %r8,%rdx
  402a44:	0f 85 79 fe ff ff    	jne    4028c3 <fc_solve_sfs_raymond_prune+0x183>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402a4a:	89 c2                	mov    %eax,%edx
                    rank_min_2 -
  402a4c:	4d 89 cb             	mov    %r9,%r11
  402a4f:	41 89 c0             	mov    %eax,%r8d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402a52:	f7 d2                	not    %edx
  402a54:	41 83 e0 01          	and    $0x1,%r8d
  402a58:	83 e2 01             	and    $0x1,%edx
                    rank_min_2 -
  402a5b:	49 29 d3             	sub    %rdx,%r11
                if (fcs_foundation_value(*ptr_state, f) <
  402a5e:	48 0f be 51 44       	movsbq 0x44(%rcx),%rdx
  402a63:	49 39 d3             	cmp    %rdx,%r11
  402a66:	0f 8f 57 fe ff ff    	jg     4028c3 <fc_solve_sfs_raymond_prune+0x183>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402a6c:	4d 0f be c0          	movsbq %r8b,%r8
                    rank_min_2 -
  402a70:	4c 89 ca             	mov    %r9,%rdx
  402a73:	4c 29 c2             	sub    %r8,%rdx
  402a76:	49 89 d0             	mov    %rdx,%r8
                if (fcs_foundation_value(*ptr_state, f) <
  402a79:	48 0f be 51 45       	movsbq 0x45(%rcx),%rdx
  402a7e:	49 39 d0             	cmp    %rdx,%r8
  402a81:	0f 8f 3c fe ff ff    	jg     4028c3 <fc_solve_sfs_raymond_prune+0x183>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402a87:	89 c2                	mov    %eax,%edx
                    rank_min_2 -
  402a89:	4d 89 c8             	mov    %r9,%r8
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402a8c:	83 f2 fd             	xor    $0xfffffffd,%edx
  402a8f:	83 e2 01             	and    $0x1,%edx
                    rank_min_2 -
  402a92:	49 29 d0             	sub    %rdx,%r8
                if (fcs_foundation_value(*ptr_state, f) <
  402a95:	48 0f be 51 46       	movsbq 0x46(%rcx),%rdx
  402a9a:	49 39 d0             	cmp    %rdx,%r8
  402a9d:	0f 8f 20 fe ff ff    	jg     4028c3 <fc_solve_sfs_raymond_prune+0x183>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402aa3:	83 e0 01             	and    $0x1,%eax
                    rank_min_2 -
  402aa6:	49 29 c1             	sub    %rax,%r9
                if (fcs_foundation_value(*ptr_state, f) <
  402aa9:	48 0f be 41 47       	movsbq 0x47(%rcx),%rax
  402aae:	49 39 c1             	cmp    %rax,%r9
  402ab1:	0f 8f 0c fe ff ff    	jg     4028c3 <fc_solve_sfs_raymond_prune+0x183>
            fcs_increment_foundation(new_state_key, dest_foundation);
  402ab7:	83 c6 01             	add    $0x1,%esi
            fcs_empty_freecell(new_state_key, fc);
  402aba:	c6 41 43 00          	movb   $0x0,0x43(%rcx)
            fcs_increment_foundation(new_state_key, dest_foundation);
  402abe:	40 88 74 39 44       	mov    %sil,0x44(%rcx,%rdi,1)
        if (num_cards_moved)
  402ac3:	41 bc 01 00 00 00    	mov    $0x1,%r12d
  402ac9:	e9 b2 fc ff ff       	jmpq   402780 <fc_solve_sfs_raymond_prune+0x40>
  402ace:	66 90                	xchg   %ax,%ax
    const int_fast32_t suit = fcs_card_suit(card);
  402ad0:	48 89 c7             	mov    %rax,%rdi
    const int_fast32_t rank = fcs_card_rank(card);
  402ad3:	89 c2                	mov    %eax,%edx
    const int_fast32_t suit = fcs_card_suit(card);
  402ad5:	83 e7 03             	and    $0x3,%edi
    const int_fast32_t rank = fcs_card_rank(card);
  402ad8:	c0 fa 02             	sar    $0x2,%dl
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402adb:	4c 0f be 44 39 44    	movsbq 0x44(%rcx,%rdi,1),%r8
    const int_fast32_t rank = fcs_card_rank(card);
  402ae1:	48 0f be d2          	movsbq %dl,%rdx
    const int_fast32_t rank_min_2 = rank - 2;
  402ae5:	4c 8d 4a fe          	lea    -0x2(%rdx),%r9
    const int_fast32_t rank_min_1 = rank - 1;
  402ae9:	48 83 ea 01          	sub    $0x1,%rdx
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402aed:	4c 89 c6             	mov    %r8,%rsi
  402af0:	4c 39 c2             	cmp    %r8,%rdx
  402af3:	0f 85 b2 fd ff ff    	jne    4028ab <fc_solve_sfs_raymond_prune+0x16b>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402af9:	89 c2                	mov    %eax,%edx
                if (fcs_foundation_value(*ptr_state, f) <
  402afb:	4c 0f be 59 44       	movsbq 0x44(%rcx),%r11
                    rank_min_2 -
  402b00:	4d 89 ce             	mov    %r9,%r14
  402b03:	41 89 c0             	mov    %eax,%r8d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402b06:	f7 d2                	not    %edx
  402b08:	41 83 e0 01          	and    $0x1,%r8d
  402b0c:	83 e2 01             	and    $0x1,%edx
                    rank_min_2 -
  402b0f:	49 29 d6             	sub    %rdx,%r14
                if (fcs_foundation_value(*ptr_state, f) <
  402b12:	4d 39 f3             	cmp    %r14,%r11
  402b15:	0f 8c 90 fd ff ff    	jl     4028ab <fc_solve_sfs_raymond_prune+0x16b>
  402b1b:	4c 0f be 59 45       	movsbq 0x45(%rcx),%r11
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402b20:	4d 0f be c0          	movsbq %r8b,%r8
                    rank_min_2 -
  402b24:	4c 89 ca             	mov    %r9,%rdx
  402b27:	4c 29 c2             	sub    %r8,%rdx
                if (fcs_foundation_value(*ptr_state, f) <
  402b2a:	49 39 d3             	cmp    %rdx,%r11
  402b2d:	0f 8c 78 fd ff ff    	jl     4028ab <fc_solve_sfs_raymond_prune+0x16b>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402b33:	89 c2                	mov    %eax,%edx
                if (fcs_foundation_value(*ptr_state, f) <
  402b35:	4c 0f be 41 46       	movsbq 0x46(%rcx),%r8
                    rank_min_2 -
  402b3a:	4d 89 cb             	mov    %r9,%r11
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402b3d:	83 f2 fd             	xor    $0xfffffffd,%edx
  402b40:	83 e2 01             	and    $0x1,%edx
                    rank_min_2 -
  402b43:	49 29 d3             	sub    %rdx,%r11
                if (fcs_foundation_value(*ptr_state, f) <
  402b46:	4d 39 d8             	cmp    %r11,%r8
  402b49:	0f 8c 5c fd ff ff    	jl     4028ab <fc_solve_sfs_raymond_prune+0x16b>
  402b4f:	48 0f be 51 47       	movsbq 0x47(%rcx),%rdx
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402b54:	83 e0 01             	and    $0x1,%eax
                    rank_min_2 -
  402b57:	49 29 c1             	sub    %rax,%r9
                if (fcs_foundation_value(*ptr_state, f) <
  402b5a:	4c 39 ca             	cmp    %r9,%rdx
  402b5d:	0f 8c 48 fd ff ff    	jl     4028ab <fc_solve_sfs_raymond_prune+0x16b>
            fcs_increment_foundation(new_state_key, dest_foundation);
  402b63:	83 c6 01             	add    $0x1,%esi
            fcs_empty_freecell(new_state_key, fc);
  402b66:	c6 41 41 00          	movb   $0x0,0x41(%rcx)
            num_cards_moved = TRUE;
  402b6a:	41 ba 01 00 00 00    	mov    $0x1,%r10d
            fcs_increment_foundation(new_state_key, dest_foundation);
  402b70:	40 88 74 39 44       	mov    %sil,0x44(%rcx,%rdi,1)
  402b75:	e9 31 fd ff ff       	jmpq   4028ab <fc_solve_sfs_raymond_prune+0x16b>
  402b7a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
    const int_fast32_t suit = fcs_card_suit(card);
  402b80:	48 89 c7             	mov    %rax,%rdi
    const int_fast32_t rank = fcs_card_rank(card);
  402b83:	89 c2                	mov    %eax,%edx
    const int_fast32_t suit = fcs_card_suit(card);
  402b85:	83 e7 03             	and    $0x3,%edi
    const int_fast32_t rank = fcs_card_rank(card);
  402b88:	c0 fa 02             	sar    $0x2,%dl
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402b8b:	4c 0f be 44 39 44    	movsbq 0x44(%rcx,%rdi,1),%r8
    const int_fast32_t rank = fcs_card_rank(card);
  402b91:	48 0f be d2          	movsbq %dl,%rdx
    const int_fast32_t rank_min_2 = rank - 2;
  402b95:	4c 8d 4a fe          	lea    -0x2(%rdx),%r9
    const int_fast32_t rank_min_1 = rank - 1;
  402b99:	48 83 ea 01          	sub    $0x1,%rdx
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402b9d:	4c 89 c6             	mov    %r8,%rsi
  402ba0:	49 39 d0             	cmp    %rdx,%r8
  402ba3:	0f 85 f6 fc ff ff    	jne    40289f <fc_solve_sfs_raymond_prune+0x15f>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402ba9:	89 c2                	mov    %eax,%edx
                    rank_min_2 -
  402bab:	4d 89 cb             	mov    %r9,%r11
  402bae:	41 89 c0             	mov    %eax,%r8d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402bb1:	f7 d2                	not    %edx
  402bb3:	41 83 e0 01          	and    $0x1,%r8d
  402bb7:	83 e2 01             	and    $0x1,%edx
                    rank_min_2 -
  402bba:	49 29 d3             	sub    %rdx,%r11
                if (fcs_foundation_value(*ptr_state, f) <
  402bbd:	48 0f be 51 44       	movsbq 0x44(%rcx),%rdx
  402bc2:	49 39 d3             	cmp    %rdx,%r11
  402bc5:	0f 8f d4 fc ff ff    	jg     40289f <fc_solve_sfs_raymond_prune+0x15f>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402bcb:	4d 0f be c0          	movsbq %r8b,%r8
                    rank_min_2 -
  402bcf:	4c 89 ca             	mov    %r9,%rdx
  402bd2:	4c 29 c2             	sub    %r8,%rdx
  402bd5:	49 89 d0             	mov    %rdx,%r8
                if (fcs_foundation_value(*ptr_state, f) <
  402bd8:	48 0f be 51 45       	movsbq 0x45(%rcx),%rdx
  402bdd:	49 39 d0             	cmp    %rdx,%r8
  402be0:	0f 8f b9 fc ff ff    	jg     40289f <fc_solve_sfs_raymond_prune+0x15f>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402be6:	89 c2                	mov    %eax,%edx
                if (fcs_foundation_value(*ptr_state, f) <
  402be8:	4c 0f be 41 46       	movsbq 0x46(%rcx),%r8
                    rank_min_2 -
  402bed:	4d 89 cb             	mov    %r9,%r11
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402bf0:	83 f2 fd             	xor    $0xfffffffd,%edx
  402bf3:	83 e2 01             	and    $0x1,%edx
                    rank_min_2 -
  402bf6:	49 29 d3             	sub    %rdx,%r11
                if (fcs_foundation_value(*ptr_state, f) <
  402bf9:	4d 39 d8             	cmp    %r11,%r8
  402bfc:	0f 8c 9d fc ff ff    	jl     40289f <fc_solve_sfs_raymond_prune+0x15f>
  402c02:	48 0f be 51 47       	movsbq 0x47(%rcx),%rdx
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402c07:	83 e0 01             	and    $0x1,%eax
                    rank_min_2 -
  402c0a:	49 29 c1             	sub    %rax,%r9
                if (fcs_foundation_value(*ptr_state, f) <
  402c0d:	4c 39 ca             	cmp    %r9,%rdx
  402c10:	0f 8c 89 fc ff ff    	jl     40289f <fc_solve_sfs_raymond_prune+0x15f>
            fcs_increment_foundation(new_state_key, dest_foundation);
  402c16:	83 c6 01             	add    $0x1,%esi
            fcs_empty_freecell(new_state_key, fc);
  402c19:	c6 41 40 00          	movb   $0x0,0x40(%rcx)
            num_cards_moved = TRUE;
  402c1d:	41 ba 01 00 00 00    	mov    $0x1,%r10d
            fcs_increment_foundation(new_state_key, dest_foundation);
  402c23:	40 88 74 39 44       	mov    %sil,0x44(%rcx,%rdi,1)
  402c28:	e9 72 fc ff ff       	jmpq   40289f <fc_solve_sfs_raymond_prune+0x15f>
  402c2d:	0f 1f 00             	nopl   (%rax)
            my_copy_stack(stack_idx);
  402c30:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  402c35:	49 89 7c 0a f8       	mov    %rdi,-0x8(%r10,%rcx,1)
  402c3a:	48 83 e9 01          	sub    $0x1,%rcx
  402c3e:	4c 89 d7             	mov    %r10,%rdi
  402c41:	48 c1 e9 03          	shr    $0x3,%rcx
  402c45:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  402c48:	e9 06 fd ff ff       	jmpq   402953 <fc_solve_sfs_raymond_prune+0x213>
        if (HT_FIELD(hard_thread, allocated_from_list))
  402c4d:	80 bb 18 05 00 00 00 	cmpb   $0x0,0x518(%rbx)
  402c54:	75 3c                	jne    402c92 <fc_solve_sfs_raymond_prune+0x552>
    allocator->ptr = allocator->rollback_ptr;
  402c56:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
  402c5d:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  402c64:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
    return (fcs_collectible_state *)(s->key);
  402c69:	e9 89 fc ff ff       	jmpq   4028f7 <fc_solve_sfs_raymond_prune+0x1b7>
}
  402c6e:	48 83 c4 38          	add    $0x38,%rsp
        return NULL;
  402c72:	31 c0                	xor    %eax,%eax
}
  402c74:	5b                   	pop    %rbx
  402c75:	5d                   	pop    %rbp
  402c76:	41 5c                	pop    %r12
  402c78:	41 5d                	pop    %r13
  402c7a:	41 5e                	pop    %r14
  402c7c:	41 5f                	pop    %r15
  402c7e:	c3                   	retq   
            my_copy_stack(stack_idx);
  402c7f:	8b 3e                	mov    (%rsi),%edi
  402c81:	41 89 3a             	mov    %edi,(%r10)
  402c84:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  402c88:	41 89 74 0a fc       	mov    %esi,-0x4(%r10,%rcx,1)
  402c8d:	e9 c1 fc ff ff       	jmpq   402953 <fc_solve_sfs_raymond_prune+0x213>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  402c92:	48 8b 93 b0 00 00 00 	mov    0xb0(%rbx),%rdx
  402c99:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  402c9e:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  402ca1:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
  402ca6:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
  402cad:	eb b5                	jmp    402c64 <fc_solve_sfs_raymond_prune+0x524>
  402caf:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  402cb4:	66 41 89 74 0a fe    	mov    %si,-0x2(%r10,%rcx,1)
  402cba:	e9 94 fc ff ff       	jmpq   402953 <fc_solve_sfs_raymond_prune+0x213>
  402cbf:	90                   	nop

0000000000402cc0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack>:
    if (soft_thread->num_vacant_stacks == 0)
  402cc0:	80 bf e3 01 00 00 00 	cmpb   $0x0,0x1e3(%rdi)
  402cc7:	0f 84 93 03 00 00    	je     403060 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3a0>
{
  402ccd:	41 57                	push   %r15
  402ccf:	49 89 f7             	mov    %rsi,%r15
  402cd2:	41 56                	push   %r14
  402cd4:	41 55                	push   %r13
  402cd6:	41 54                	push   %r12
  402cd8:	55                   	push   %rbp
  402cd9:	48 89 fd             	mov    %rdi,%rbp
  402cdc:	53                   	push   %rbx
  402cdd:	48 89 cb             	mov    %rcx,%rbx
  402ce0:	48 83 ec 48          	sub    $0x48,%rsp
        if (fcs_state_col_is_empty(state, ret))
  402ce4:	48 8b 06             	mov    (%rsi),%rax
  402ce7:	48 89 54 24 08       	mov    %rdx,0x8(%rsp)
  402cec:	80 38 00             	cmpb   $0x0,(%rax)
  402cef:	0f 84 ad 08 00 00    	je     4035a2 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x8e2>
  402cf5:	48 8b 46 08          	mov    0x8(%rsi),%rax
  402cf9:	80 38 00             	cmpb   $0x0,(%rax)
  402cfc:	0f 84 ad 08 00 00    	je     4035af <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x8ef>
  402d02:	48 8b 46 10          	mov    0x10(%rsi),%rax
  402d06:	80 38 00             	cmpb   $0x0,(%rax)
  402d09:	0f 84 ad 08 00 00    	je     4035bc <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x8fc>
  402d0f:	48 8b 46 18          	mov    0x18(%rsi),%rax
  402d13:	80 38 00             	cmpb   $0x0,(%rax)
  402d16:	0f 84 ad 08 00 00    	je     4035c9 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x909>
  402d1c:	48 8b 46 20          	mov    0x20(%rsi),%rax
  402d20:	80 38 00             	cmpb   $0x0,(%rax)
  402d23:	0f 84 84 07 00 00    	je     4034ad <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x7ed>
  402d29:	48 8b 46 28          	mov    0x28(%rsi),%rax
  402d2d:	80 38 00             	cmpb   $0x0,(%rax)
  402d30:	0f 84 a0 08 00 00    	je     4035d6 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x916>
  402d36:	48 8b 46 30          	mov    0x30(%rsi),%rax
  402d3a:	80 38 00             	cmpb   $0x0,(%rax)
  402d3d:	0f 84 a0 08 00 00    	je     4035e3 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x923>
  402d43:	48 8b 46 38          	mov    0x38(%rsi),%rax
  402d47:	80 38 00             	cmpb   $0x0,(%rax)
  402d4a:	0f 84 a0 08 00 00    	je     4035f0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x930>
    tests_define_accessors();
  402d50:	4c 8b 2f             	mov    (%rdi),%r13
        if (fcs_card_is_empty(card) ||
  402d53:	45 31 e4             	xor    %r12d,%r12d
    return -1;
  402d56:	c7 44 24 04 ff ff ff 	movl   $0xffffffff,0x4(%rsp)
  402d5d:	ff 
        const fcs_card card = fcs_freecell_card(state, fc);
  402d5e:	44 0f b6 56 40       	movzbl 0x40(%rsi),%r10d
        my_copy_stack(ds);
  402d63:	49 8d 85 80 00 00 00 	lea    0x80(%r13),%rax
  402d6a:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
        if (fcs_card_is_empty(card) ||
  402d6f:	45 84 d2             	test   %r10b,%r10b
  402d72:	0f 85 18 03 00 00    	jne    403090 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3d0>
        const fcs_card card = fcs_freecell_card(state, fc);
  402d78:	45 0f b6 57 41       	movzbl 0x41(%r15),%r10d
        if (fcs_card_is_empty(card) ||
  402d7d:	45 84 d2             	test   %r10b,%r10b
  402d80:	44 88 54 24 18       	mov    %r10b,0x18(%rsp)
  402d85:	0f 84 de 00 00 00    	je     402e69 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x1a9>
        sfs_check_state_begin();
  402d8b:	48 8b 4c 24 08       	mov    0x8(%rsp),%rcx
  402d90:	4c 8d 74 24 20       	lea    0x20(%rsp),%r14
  402d95:	4c 89 fa             	mov    %r15,%rdx
  402d98:	4c 89 ef             	mov    %r13,%rdi
  402d9b:	4c 89 f6             	mov    %r14,%rsi
  402d9e:	e8 7d ec ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
        my_copy_stack(ds);
  402da3:	48 8b 54 24 28       	mov    0x28(%rsp),%rdx
  402da8:	44 0f b6 54 24 18    	movzbl 0x18(%rsp),%r10d
  402dae:	8b 42 14             	mov    0x14(%rdx),%eax
  402db1:	44 85 e0             	test   %r12d,%eax
  402db4:	0f 84 e6 03 00 00    	je     4031a0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x4e0>
  402dba:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  402dbf:	48 63 54 24 04       	movslq 0x4(%rsp),%rdx
        fcs_empty_freecell(new_state_key, fc);
  402dc4:	c6 40 41 00          	movb   $0x0,0x41(%rax)
}

static inline void fcs_state_push(
    fcs_state *const state, const int col_idx, const fcs_card card)
{
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  402dc8:	48 8b 14 d0          	mov    (%rax,%rdx,8),%rdx
    if (!fc_solve_check_and_add_state(
  402dcc:	4c 89 f6             	mov    %r14,%rsi
    fcs_col_push_card(col, card);
  402dcf:	48 0f be 02          	movsbq (%rdx),%rax
  402dd3:	8d 48 01             	lea    0x1(%rax),%ecx
  402dd6:	88 0a                	mov    %cl,(%rdx)
  402dd8:	44 88 54 02 01       	mov    %r10b,0x1(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  402ddd:	48 8b 4d 00          	mov    0x0(%rbp),%rcx
    if (!fc_solve_check_and_add_state(
  402de1:	48 8d 54 24 30       	lea    0x30(%rsp),%rdx
  402de6:	48 89 cf             	mov    %rcx,%rdi
  402de9:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
  402dee:	e8 7d ed ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  402df3:	84 c0                	test   %al,%al
  402df5:	75 39                	jne    402e30 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x170>
  402df7:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
        if (HT_FIELD(hard_thread, allocated_from_list))
  402dfc:	80 b9 18 05 00 00 00 	cmpb   $0x0,0x518(%rcx)
  402e03:	0f 84 f7 04 00 00    	je     403300 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x640>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  402e09:	48 8b 91 b0 00 00 00 	mov    0xb0(%rcx),%rdx
  402e10:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  402e15:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  402e18:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  402e1d:	48 89 81 b0 00 00 00 	mov    %rax,0xb0(%rcx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  402e24:	4c 8b 74 24 30       	mov    0x30(%rsp),%r14
    return (fcs_collectible_state *)(s->key);
  402e29:	eb 0a                	jmp    402e35 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x175>
  402e2b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  402e30:	4c 8b 74 24 20       	mov    0x20(%rsp),%r14

#define DERIVED_STATES_LIST_GROW_BY 16
void fc_solve_derived_states_list_add_state(fcs_derived_states_list *const list,
    fcs_collectible_state *const state, const int context)
{
    if ((!((list->num_states + (list->states != NULL)) &
  402e35:	48 8b 43 08          	mov    0x8(%rbx),%rax
  402e39:	31 c9                	xor    %ecx,%ecx
  402e3b:	48 8b 13             	mov    (%rbx),%rdx
  402e3e:	48 85 c0             	test   %rax,%rax
  402e41:	0f 95 c1             	setne  %cl
  402e44:	48 01 d1             	add    %rdx,%rcx
  402e47:	f6 c1 0f             	test   $0xf,%cl
  402e4a:	0f 84 50 04 00 00    	je     4032a0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x5e0>
    {
        list->states =
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
                                       DERIVED_STATES_LIST_GROW_BY);
    }
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  402e50:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  402e54:	48 c1 e2 04          	shl    $0x4,%rdx
  402e58:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  402e5c:	48 01 c2             	add    %rax,%rdx
  402e5f:	48 89 0b             	mov    %rcx,(%rbx)
  402e62:	c5 f8 11 02          	vmovups %xmm0,(%rdx)
  402e66:	4c 89 32             	mov    %r14,(%rdx)
        const fcs_card card = fcs_freecell_card(state, fc);
  402e69:	45 0f b6 57 42       	movzbl 0x42(%r15),%r10d
        if (fcs_card_is_empty(card) ||
  402e6e:	45 84 d2             	test   %r10b,%r10b
  402e71:	44 88 54 24 18       	mov    %r10b,0x18(%rsp)
  402e76:	0f 84 dd 00 00 00    	je     402f59 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x299>
        sfs_check_state_begin();
  402e7c:	48 8b 4c 24 08       	mov    0x8(%rsp),%rcx
  402e81:	4c 8d 74 24 20       	lea    0x20(%rsp),%r14
  402e86:	4c 89 fa             	mov    %r15,%rdx
  402e89:	4c 89 ef             	mov    %r13,%rdi
  402e8c:	4c 89 f6             	mov    %r14,%rsi
  402e8f:	e8 8c eb ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
        my_copy_stack(ds);
  402e94:	48 8b 54 24 28       	mov    0x28(%rsp),%rdx
  402e99:	44 0f b6 54 24 18    	movzbl 0x18(%rsp),%r10d
  402e9f:	8b 42 14             	mov    0x14(%rdx),%eax
  402ea2:	44 85 e0             	test   %r12d,%eax
  402ea5:	0f 84 65 03 00 00    	je     403210 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x550>
  402eab:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  402eb0:	48 63 54 24 04       	movslq 0x4(%rsp),%rdx
        fcs_empty_freecell(new_state_key, fc);
  402eb5:	c6 40 42 00          	movb   $0x0,0x42(%rax)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  402eb9:	48 8b 14 d0          	mov    (%rax,%rdx,8),%rdx
    if (!fc_solve_check_and_add_state(
  402ebd:	4c 89 f6             	mov    %r14,%rsi
    fcs_col_push_card(col, card);
  402ec0:	48 0f be 02          	movsbq (%rdx),%rax
  402ec4:	8d 48 01             	lea    0x1(%rax),%ecx
  402ec7:	88 0a                	mov    %cl,(%rdx)
  402ec9:	44 88 54 02 01       	mov    %r10b,0x1(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  402ece:	48 8b 4d 00          	mov    0x0(%rbp),%rcx
    if (!fc_solve_check_and_add_state(
  402ed2:	48 8d 54 24 30       	lea    0x30(%rsp),%rdx
  402ed7:	48 89 cf             	mov    %rcx,%rdi
  402eda:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
  402edf:	e8 8c ec ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  402ee4:	84 c0                	test   %al,%al
  402ee6:	75 38                	jne    402f20 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x260>
  402ee8:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
        if (HT_FIELD(hard_thread, allocated_from_list))
  402eed:	80 b9 18 05 00 00 00 	cmpb   $0x0,0x518(%rcx)
  402ef4:	0f 84 e6 03 00 00    	je     4032e0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x620>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  402efa:	48 8b 91 b0 00 00 00 	mov    0xb0(%rcx),%rdx
  402f01:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  402f06:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  402f09:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  402f0e:	48 89 81 b0 00 00 00 	mov    %rax,0xb0(%rcx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  402f15:	4c 8b 74 24 30       	mov    0x30(%rsp),%r14
    return (fcs_collectible_state *)(s->key);
  402f1a:	eb 09                	jmp    402f25 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x265>
  402f1c:	0f 1f 40 00          	nopl   0x0(%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  402f20:	4c 8b 74 24 20       	mov    0x20(%rsp),%r14
    if ((!((list->num_states + (list->states != NULL)) &
  402f25:	48 8b 43 08          	mov    0x8(%rbx),%rax
  402f29:	31 c9                	xor    %ecx,%ecx
  402f2b:	48 8b 13             	mov    (%rbx),%rdx
  402f2e:	48 85 c0             	test   %rax,%rax
  402f31:	0f 95 c1             	setne  %cl
  402f34:	48 01 d1             	add    %rdx,%rcx
  402f37:	f6 c1 0f             	test   $0xf,%cl
  402f3a:	0f 84 40 03 00 00    	je     403280 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x5c0>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  402f40:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  402f44:	48 c1 e2 04          	shl    $0x4,%rdx
  402f48:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  402f4c:	48 01 c2             	add    %rax,%rdx
  402f4f:	48 89 0b             	mov    %rcx,(%rbx)
  402f52:	c5 f8 11 02          	vmovups %xmm0,(%rdx)
  402f56:	4c 89 32             	mov    %r14,(%rdx)
        const fcs_card card = fcs_freecell_card(state, fc);
  402f59:	45 0f b6 57 43       	movzbl 0x43(%r15),%r10d
        if (fcs_card_is_empty(card) ||
  402f5e:	45 84 d2             	test   %r10b,%r10b
  402f61:	44 88 54 24 18       	mov    %r10b,0x18(%rsp)
  402f66:	0f 84 d9 00 00 00    	je     403045 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x385>
        sfs_check_state_begin();
  402f6c:	48 8b 4c 24 08       	mov    0x8(%rsp),%rcx
  402f71:	4c 8d 74 24 20       	lea    0x20(%rsp),%r14
  402f76:	4c 89 fa             	mov    %r15,%rdx
  402f79:	4c 89 ef             	mov    %r13,%rdi
  402f7c:	4c 89 f6             	mov    %r14,%rsi
  402f7f:	e8 9c ea ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
        my_copy_stack(ds);
  402f84:	48 8b 54 24 28       	mov    0x28(%rsp),%rdx
  402f89:	44 0f b6 54 24 18    	movzbl 0x18(%rsp),%r10d
  402f8f:	8b 42 14             	mov    0x14(%rdx),%eax
  402f92:	44 85 e0             	test   %r12d,%eax
  402f95:	0f 84 95 01 00 00    	je     403130 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x470>
  402f9b:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  402fa0:	48 63 54 24 04       	movslq 0x4(%rsp),%rdx
        fcs_empty_freecell(new_state_key, fc);
  402fa5:	c6 40 43 00          	movb   $0x0,0x43(%rax)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  402fa9:	48 8b 14 d0          	mov    (%rax,%rdx,8),%rdx
    if (!fc_solve_check_and_add_state(
  402fad:	4c 89 f6             	mov    %r14,%rsi
    fcs_col_push_card(col, card);
  402fb0:	48 0f be 02          	movsbq (%rdx),%rax
  402fb4:	8d 48 01             	lea    0x1(%rax),%ecx
  402fb7:	88 0a                	mov    %cl,(%rdx)
  402fb9:	44 88 54 02 01       	mov    %r10b,0x1(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  402fbe:	48 8b 6d 00          	mov    0x0(%rbp),%rbp
    if (!fc_solve_check_and_add_state(
  402fc2:	48 8d 54 24 30       	lea    0x30(%rsp),%rdx
  402fc7:	48 89 ef             	mov    %rbp,%rdi
  402fca:	e8 a1 eb ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  402fcf:	84 c0                	test   %al,%al
  402fd1:	75 3d                	jne    403010 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x350>
        if (HT_FIELD(hard_thread, allocated_from_list))
  402fd3:	80 bd 18 05 00 00 00 	cmpb   $0x0,0x518(%rbp)
  402fda:	0f 84 e0 02 00 00    	je     4032c0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x600>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  402fe0:	48 8b 95 b0 00 00 00 	mov    0xb0(%rbp),%rdx
  402fe7:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  402fec:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  402fef:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  402ff4:	48 89 85 b0 00 00 00 	mov    %rax,0xb0(%rbp)
        return FCS_STATE_kv_to_collectible(&existing_state);
  402ffb:	48 8b 6c 24 30       	mov    0x30(%rsp),%rbp
    return (fcs_collectible_state *)(s->key);
  403000:	eb 13                	jmp    403015 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x355>
  403002:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403009:	00 00 00 00 
  40300d:	0f 1f 00             	nopl   (%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  403010:	48 8b 6c 24 20       	mov    0x20(%rsp),%rbp
    if ((!((list->num_states + (list->states != NULL)) &
  403015:	48 8b 43 08          	mov    0x8(%rbx),%rax
  403019:	31 c9                	xor    %ecx,%ecx
  40301b:	48 8b 13             	mov    (%rbx),%rdx
  40301e:	48 85 c0             	test   %rax,%rax
  403021:	0f 95 c1             	setne  %cl
  403024:	48 01 d1             	add    %rdx,%rcx
  403027:	f6 c1 0f             	test   $0xf,%cl
  40302a:	74 44                	je     403070 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3b0>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  40302c:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  403030:	48 c1 e2 04          	shl    $0x4,%rdx
  403034:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  403038:	48 01 d0             	add    %rdx,%rax
  40303b:	48 89 0b             	mov    %rcx,(%rbx)
  40303e:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  403042:	48 89 28             	mov    %rbp,(%rax)
}
  403045:	48 83 c4 48          	add    $0x48,%rsp
  403049:	5b                   	pop    %rbx
  40304a:	5d                   	pop    %rbp
  40304b:	41 5c                	pop    %r12
  40304d:	41 5d                	pop    %r13
  40304f:	41 5e                	pop    %r14
  403051:	41 5f                	pop    %r15
  403053:	c3                   	retq   
  403054:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40305b:	00 00 00 00 
  40305f:	90                   	nop
  403060:	c3                   	retq   
  403061:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403068:	00 00 00 00 
  40306c:	0f 1f 40 00          	nopl   0x0(%rax)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  403070:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  403074:	48 89 c7             	mov    %rax,%rdi
  403077:	48 c1 e6 04          	shl    $0x4,%rsi
  40307b:	e8 f0 e0 ff ff       	callq  401170 <realloc@plt>
  403080:	48 8b 13             	mov    (%rbx),%rdx
        list->states =
  403083:	48 89 43 08          	mov    %rax,0x8(%rbx)
  403087:	eb a3                	jmp    40302c <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x36c>
  403089:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        sfs_check_state_begin();
  403090:	4c 8d 74 24 20       	lea    0x20(%rsp),%r14
  403095:	48 89 d1             	mov    %rdx,%rcx
  403098:	4c 89 ef             	mov    %r13,%rdi
  40309b:	44 88 54 24 18       	mov    %r10b,0x18(%rsp)
  4030a0:	4c 89 fa             	mov    %r15,%rdx
  4030a3:	4c 89 f6             	mov    %r14,%rsi
        my_copy_stack(ds);
  4030a6:	45 31 e4             	xor    %r12d,%r12d
        sfs_check_state_begin();
  4030a9:	e8 72 e9 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
        my_copy_stack(ds);
  4030ae:	48 8b 54 24 28       	mov    0x28(%rsp),%rdx
    return -1;
  4030b3:	c7 44 24 04 ff ff ff 	movl   $0xffffffff,0x4(%rsp)
  4030ba:	ff 
  4030bb:	44 0f b6 54 24 18    	movzbl 0x18(%rsp),%r10d
        my_copy_stack(ds);
  4030c1:	8b 42 14             	mov    0x14(%rdx),%eax
  4030c4:	44 09 e0             	or     %r12d,%eax
  4030c7:	89 42 14             	mov    %eax,0x14(%rdx)
  4030ca:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  4030cf:	48 63 54 24 04       	movslq 0x4(%rsp),%rdx
  4030d4:	48 8b 34 d0          	mov    (%rax,%rdx,8),%rsi
  4030d8:	0f be 0e             	movsbl (%rsi),%ecx
  4030db:	83 c1 01             	add    $0x1,%ecx
  4030de:	48 63 c9             	movslq %ecx,%rcx
  4030e1:	48 83 f9 08          	cmp    $0x8,%rcx
  4030e5:	0f 83 55 02 00 00    	jae    403340 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x680>
  4030eb:	f6 c1 04             	test   $0x4,%cl
  4030ee:	0f 85 42 04 00 00    	jne    403536 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x876>
  4030f4:	48 85 c9             	test   %rcx,%rcx
  4030f7:	0f 84 62 02 00 00    	je     40335f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x69f>
  4030fd:	0f b6 06             	movzbl (%rsi),%eax
  403100:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  403105:	88 07                	mov    %al,(%rdi)
  403107:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  40310c:	f6 c1 02             	test   $0x2,%cl
  40310f:	0f 84 4a 02 00 00    	je     40335f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x69f>
  403115:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  40311a:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  40311f:	66 89 44 0e fe       	mov    %ax,-0x2(%rsi,%rcx,1)
  403124:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403129:	e9 31 02 00 00       	jmpq   40335f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x69f>
  40312e:	66 90                	xchg   %ax,%ax
  403130:	41 09 c4             	or     %eax,%r12d
  403133:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403138:	44 89 62 14          	mov    %r12d,0x14(%rdx)
  40313c:	48 63 54 24 04       	movslq 0x4(%rsp),%rdx
  403141:	48 8b 34 d0          	mov    (%rax,%rdx,8),%rsi
  403145:	0f be 0e             	movsbl (%rsi),%ecx
  403148:	83 c1 01             	add    $0x1,%ecx
  40314b:	48 63 c9             	movslq %ecx,%rcx
  40314e:	48 83 f9 08          	cmp    $0x8,%rcx
  403152:	0f 83 fb 02 00 00    	jae    403453 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x793>
  403158:	f6 c1 04             	test   $0x4,%cl
  40315b:	0f 85 0b 04 00 00    	jne    40356c <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x8ac>
  403161:	48 85 c9             	test   %rcx,%rcx
  403164:	0f 84 08 03 00 00    	je     403472 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x7b2>
  40316a:	0f b6 06             	movzbl (%rsi),%eax
  40316d:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  403172:	88 07                	mov    %al,(%rdi)
  403174:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403179:	f6 c1 02             	test   $0x2,%cl
  40317c:	0f 84 f0 02 00 00    	je     403472 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x7b2>
  403182:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  403187:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  40318c:	66 89 44 0e fe       	mov    %ax,-0x2(%rsi,%rcx,1)
  403191:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403196:	e9 d7 02 00 00       	jmpq   403472 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x7b2>
  40319b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  4031a0:	44 09 e0             	or     %r12d,%eax
  4031a3:	89 42 14             	mov    %eax,0x14(%rdx)
  4031a6:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  4031ab:	48 63 54 24 04       	movslq 0x4(%rsp),%rdx
  4031b0:	48 8b 34 d0          	mov    (%rax,%rdx,8),%rsi
  4031b4:	0f be 0e             	movsbl (%rsi),%ecx
  4031b7:	83 c1 01             	add    $0x1,%ecx
  4031ba:	48 63 c9             	movslq %ecx,%rcx
  4031bd:	48 83 f9 08          	cmp    $0x8,%rcx
  4031c1:	0f 83 b9 02 00 00    	jae    403480 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x7c0>
  4031c7:	f6 c1 04             	test   $0x4,%cl
  4031ca:	0f 85 81 03 00 00    	jne    403551 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x891>
  4031d0:	48 85 c9             	test   %rcx,%rcx
  4031d3:	0f 84 c6 02 00 00    	je     40349f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x7df>
  4031d9:	0f b6 06             	movzbl (%rsi),%eax
  4031dc:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  4031e1:	88 07                	mov    %al,(%rdi)
  4031e3:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  4031e8:	f6 c1 02             	test   $0x2,%cl
  4031eb:	0f 84 ae 02 00 00    	je     40349f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x7df>
  4031f1:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  4031f6:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  4031fb:	66 89 44 0e fe       	mov    %ax,-0x2(%rsi,%rcx,1)
  403200:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403205:	e9 95 02 00 00       	jmpq   40349f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x7df>
  40320a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  403210:	44 09 e0             	or     %r12d,%eax
  403213:	89 42 14             	mov    %eax,0x14(%rdx)
  403216:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  40321b:	48 63 54 24 04       	movslq 0x4(%rsp),%rdx
  403220:	48 8b 34 d0          	mov    (%rax,%rdx,8),%rsi
  403224:	0f be 0e             	movsbl (%rsi),%ecx
  403227:	83 c1 01             	add    $0x1,%ecx
  40322a:	48 63 c9             	movslq %ecx,%rcx
  40322d:	48 83 f9 08          	cmp    $0x8,%rcx
  403231:	0f 83 dc 00 00 00    	jae    403313 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x653>
  403237:	f6 c1 04             	test   $0x4,%cl
  40323a:	0f 85 47 03 00 00    	jne    403587 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x8c7>
  403240:	48 85 c9             	test   %rcx,%rcx
  403243:	0f 84 e9 00 00 00    	je     403332 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x672>
  403249:	0f b6 06             	movzbl (%rsi),%eax
  40324c:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  403251:	88 07                	mov    %al,(%rdi)
  403253:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403258:	f6 c1 02             	test   $0x2,%cl
  40325b:	0f 84 d1 00 00 00    	je     403332 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x672>
  403261:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  403266:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  40326b:	66 89 44 0e fe       	mov    %ax,-0x2(%rsi,%rcx,1)
  403270:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403275:	e9 b8 00 00 00       	jmpq   403332 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x672>
  40327a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  403280:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  403284:	48 89 c7             	mov    %rax,%rdi
  403287:	48 c1 e6 04          	shl    $0x4,%rsi
  40328b:	e8 e0 de ff ff       	callq  401170 <realloc@plt>
  403290:	48 8b 13             	mov    (%rbx),%rdx
        list->states =
  403293:	48 89 43 08          	mov    %rax,0x8(%rbx)
  403297:	e9 a4 fc ff ff       	jmpq   402f40 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x280>
  40329c:	0f 1f 40 00          	nopl   0x0(%rax)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  4032a0:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  4032a4:	48 89 c7             	mov    %rax,%rdi
  4032a7:	48 c1 e6 04          	shl    $0x4,%rsi
  4032ab:	e8 c0 de ff ff       	callq  401170 <realloc@plt>
  4032b0:	48 8b 13             	mov    (%rbx),%rdx
        list->states =
  4032b3:	48 89 43 08          	mov    %rax,0x8(%rbx)
  4032b7:	e9 94 fb ff ff       	jmpq   402e50 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x190>
  4032bc:	0f 1f 40 00          	nopl   0x0(%rax)
  4032c0:	48 8b 85 f0 00 00 00 	mov    0xf0(%rbp),%rax
  4032c7:	48 89 85 e8 00 00 00 	mov    %rax,0xe8(%rbp)
  4032ce:	e9 28 fd ff ff       	jmpq   402ffb <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x33b>
  4032d3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4032da:	00 00 00 00 
  4032de:	66 90                	xchg   %ax,%ax
  4032e0:	48 8b 81 f0 00 00 00 	mov    0xf0(%rcx),%rax
  4032e7:	48 89 81 e8 00 00 00 	mov    %rax,0xe8(%rcx)
  4032ee:	e9 22 fc ff ff       	jmpq   402f15 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x255>
  4032f3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4032fa:	00 00 00 00 
  4032fe:	66 90                	xchg   %ax,%ax
  403300:	48 8b 81 f0 00 00 00 	mov    0xf0(%rcx),%rax
  403307:	48 89 81 e8 00 00 00 	mov    %rax,0xe8(%rcx)
  40330e:	e9 11 fb ff ff       	jmpq   402e24 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x164>
  403313:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  403318:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  40331d:	48 89 44 0f f8       	mov    %rax,-0x8(%rdi,%rcx,1)
  403322:	48 83 e9 01          	sub    $0x1,%rcx
  403326:	48 c1 e9 03          	shr    $0x3,%rcx
  40332a:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40332d:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403332:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  403337:	48 89 34 d0          	mov    %rsi,(%rax,%rdx,8)
  40333b:	e9 75 fb ff ff       	jmpq   402eb5 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x1f5>
  403340:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  403345:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  40334a:	48 89 44 0f f8       	mov    %rax,-0x8(%rdi,%rcx,1)
  40334f:	48 83 e9 01          	sub    $0x1,%rcx
  403353:	48 c1 e9 03          	shr    $0x3,%rcx
  403357:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40335a:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  40335f:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  403364:	48 89 34 d0          	mov    %rsi,(%rax,%rdx,8)
        fcs_empty_freecell(new_state_key, fc);
  403368:	c6 40 40 00          	movb   $0x0,0x40(%rax)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  40336c:	48 8b 14 d0          	mov    (%rax,%rdx,8),%rdx
    if (!fc_solve_check_and_add_state(
  403370:	4c 89 f6             	mov    %r14,%rsi
    fcs_col_push_card(col, card);
  403373:	48 0f be 02          	movsbq (%rdx),%rax
  403377:	8d 48 01             	lea    0x1(%rax),%ecx
  40337a:	88 0a                	mov    %cl,(%rdx)
  40337c:	44 88 54 02 01       	mov    %r10b,0x1(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  403381:	48 8b 4d 00          	mov    0x0(%rbp),%rcx
    if (!fc_solve_check_and_add_state(
  403385:	48 8d 54 24 30       	lea    0x30(%rsp),%rdx
  40338a:	48 89 cf             	mov    %rcx,%rdi
  40338d:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
  403392:	e8 d9 e7 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  403397:	84 c0                	test   %al,%al
  403399:	75 75                	jne    403410 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x750>
  40339b:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
        if (HT_FIELD(hard_thread, allocated_from_list))
  4033a0:	80 b9 18 05 00 00 00 	cmpb   $0x0,0x518(%rcx)
  4033a7:	0f 84 93 00 00 00    	je     403440 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x780>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  4033ad:	48 8b 91 b0 00 00 00 	mov    0xb0(%rcx),%rdx
  4033b4:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  4033b9:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  4033bc:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  4033c1:	48 89 81 b0 00 00 00 	mov    %rax,0xb0(%rcx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  4033c8:	4c 8b 74 24 30       	mov    0x30(%rsp),%r14
    if ((!((list->num_states + (list->states != NULL)) &
  4033cd:	48 8b 43 08          	mov    0x8(%rbx),%rax
  4033d1:	31 c9                	xor    %ecx,%ecx
  4033d3:	48 8b 13             	mov    (%rbx),%rdx
  4033d6:	48 85 c0             	test   %rax,%rax
  4033d9:	0f 95 c1             	setne  %cl
  4033dc:	48 01 d1             	add    %rdx,%rcx
  4033df:	f6 c1 0f             	test   $0xf,%cl
  4033e2:	74 3c                	je     403420 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x760>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  4033e4:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  4033e8:	48 c1 e2 04          	shl    $0x4,%rdx
  4033ec:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4033f0:	48 01 c2             	add    %rax,%rdx
  4033f3:	48 89 0b             	mov    %rcx,(%rbx)
  4033f6:	c5 f8 11 02          	vmovups %xmm0,(%rdx)
  4033fa:	4c 89 32             	mov    %r14,(%rdx)
  4033fd:	e9 76 f9 ff ff       	jmpq   402d78 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0xb8>
  403402:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403409:	00 00 00 00 
  40340d:	0f 1f 00             	nopl   (%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  403410:	4c 8b 74 24 20       	mov    0x20(%rsp),%r14
  403415:	eb b6                	jmp    4033cd <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x70d>
  403417:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40341e:	00 00 
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  403420:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  403424:	48 89 c7             	mov    %rax,%rdi
  403427:	48 c1 e6 04          	shl    $0x4,%rsi
  40342b:	e8 40 dd ff ff       	callq  401170 <realloc@plt>
  403430:	48 8b 13             	mov    (%rbx),%rdx
        list->states =
  403433:	48 89 43 08          	mov    %rax,0x8(%rbx)
  403437:	eb ab                	jmp    4033e4 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x724>
  403439:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  403440:	48 8b 81 f0 00 00 00 	mov    0xf0(%rcx),%rax
  403447:	48 89 81 e8 00 00 00 	mov    %rax,0xe8(%rcx)
  40344e:	e9 75 ff ff ff       	jmpq   4033c8 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x708>
        my_copy_stack(ds);
  403453:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  403458:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  40345d:	48 89 44 0f f8       	mov    %rax,-0x8(%rdi,%rcx,1)
  403462:	48 83 e9 01          	sub    $0x1,%rcx
  403466:	48 c1 e9 03          	shr    $0x3,%rcx
  40346a:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40346d:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403472:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  403477:	48 89 34 d0          	mov    %rsi,(%rax,%rdx,8)
  40347b:	e9 25 fb ff ff       	jmpq   402fa5 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x2e5>
  403480:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  403485:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  40348a:	48 89 44 0f f8       	mov    %rax,-0x8(%rdi,%rcx,1)
  40348f:	48 83 e9 01          	sub    $0x1,%rcx
  403493:	48 c1 e9 03          	shr    $0x3,%rcx
  403497:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40349a:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  40349f:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  4034a4:	48 89 34 d0          	mov    %rsi,(%rax,%rdx,8)
  4034a8:	e9 17 f9 ff ff       	jmpq   402dc4 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x104>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4034ad:	c7 44 24 04 04 00 00 	movl   $0x4,0x4(%rsp)
  4034b4:	00 
  4034b5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4034bc:	00 00 00 00 
  4034c0:	8b 44 24 04          	mov    0x4(%rsp),%eax
  4034c4:	41 bc 01 00 00 00    	mov    $0x1,%r12d
        const fcs_card card = fcs_freecell_card(state, fc);
  4034ca:	45 0f b6 57 40       	movzbl 0x40(%r15),%r10d
    tests_define_accessors();
  4034cf:	4c 8b 6d 00          	mov    0x0(%rbp),%r13
    for (int fc = 0; fc < LOCAL_FREECELLS_NUM; fc++)
  4034d3:	89 c1                	mov    %eax,%ecx
        my_copy_stack(ds);
  4034d5:	c1 e0 07             	shl    $0x7,%eax
  4034d8:	48 98                	cltq   
  4034da:	41 d3 e4             	shl    %cl,%r12d
        if (fcs_card_is_empty(card) ||
  4034dd:	45 84 d2             	test   %r10b,%r10b
  4034e0:	44 88 54 24 18       	mov    %r10b,0x18(%rsp)
        my_copy_stack(ds);
  4034e5:	49 8d 84 05 00 01 00 	lea    0x100(%r13,%rax,1),%rax
  4034ec:	00 
  4034ed:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
        if (fcs_card_is_empty(card) ||
  4034f2:	0f 84 80 f8 ff ff    	je     402d78 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0xb8>
        sfs_check_state_begin();
  4034f8:	48 8b 4c 24 08       	mov    0x8(%rsp),%rcx
  4034fd:	4c 8d 74 24 20       	lea    0x20(%rsp),%r14
  403502:	4c 89 fa             	mov    %r15,%rdx
  403505:	4c 89 ef             	mov    %r13,%rdi
  403508:	4c 89 f6             	mov    %r14,%rsi
  40350b:	e8 10 e5 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
        my_copy_stack(ds);
  403510:	48 8b 54 24 28       	mov    0x28(%rsp),%rdx
  403515:	44 0f b6 54 24 18    	movzbl 0x18(%rsp),%r10d
  40351b:	8b 42 14             	mov    0x14(%rdx),%eax
  40351e:	44 85 e0             	test   %r12d,%eax
  403521:	0f 84 9d fb ff ff    	je     4030c4 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x404>
  403527:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  40352c:	48 63 54 24 04       	movslq 0x4(%rsp),%rdx
  403531:	e9 32 fe ff ff       	jmpq   403368 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x6a8>
  403536:	8b 06                	mov    (%rsi),%eax
  403538:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  40353d:	89 07                	mov    %eax,(%rdi)
  40353f:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  403543:	89 44 0f fc          	mov    %eax,-0x4(%rdi,%rcx,1)
  403547:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  40354c:	e9 0e fe ff ff       	jmpq   40335f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x69f>
  403551:	8b 06                	mov    (%rsi),%eax
  403553:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  403558:	89 07                	mov    %eax,(%rdi)
  40355a:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  40355e:	89 44 0f fc          	mov    %eax,-0x4(%rdi,%rcx,1)
  403562:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403567:	e9 33 ff ff ff       	jmpq   40349f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x7df>
  40356c:	8b 06                	mov    (%rsi),%eax
  40356e:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  403573:	89 07                	mov    %eax,(%rdi)
  403575:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  403579:	89 44 0f fc          	mov    %eax,-0x4(%rdi,%rcx,1)
  40357d:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403582:	e9 eb fe ff ff       	jmpq   403472 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x7b2>
  403587:	8b 06                	mov    (%rsi),%eax
  403589:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  40358e:	89 07                	mov    %eax,(%rdi)
  403590:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  403594:	89 44 0f fc          	mov    %eax,-0x4(%rdi,%rcx,1)
  403598:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  40359d:	e9 90 fd ff ff       	jmpq   403332 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x672>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4035a2:	c7 44 24 04 00 00 00 	movl   $0x0,0x4(%rsp)
  4035a9:	00 
  4035aa:	e9 11 ff ff ff       	jmpq   4034c0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x800>
  4035af:	c7 44 24 04 01 00 00 	movl   $0x1,0x4(%rsp)
  4035b6:	00 
  4035b7:	e9 04 ff ff ff       	jmpq   4034c0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x800>
  4035bc:	c7 44 24 04 02 00 00 	movl   $0x2,0x4(%rsp)
  4035c3:	00 
  4035c4:	e9 f7 fe ff ff       	jmpq   4034c0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x800>
  4035c9:	c7 44 24 04 03 00 00 	movl   $0x3,0x4(%rsp)
  4035d0:	00 
  4035d1:	e9 ea fe ff ff       	jmpq   4034c0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x800>
  4035d6:	c7 44 24 04 05 00 00 	movl   $0x5,0x4(%rsp)
  4035dd:	00 
  4035de:	e9 dd fe ff ff       	jmpq   4034c0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x800>
  4035e3:	c7 44 24 04 06 00 00 	movl   $0x6,0x4(%rsp)
  4035ea:	00 
  4035eb:	e9 d0 fe ff ff       	jmpq   4034c0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x800>
  4035f0:	c7 44 24 04 07 00 00 	movl   $0x7,0x4(%rsp)
  4035f7:	00 
  4035f8:	e9 c3 fe ff ff       	jmpq   4034c0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x800>
  4035fd:	0f 1f 00             	nopl   (%rax)

0000000000403600 <fc_solve_sfs_atomic_move_freecell_card_to_parent>:
{
  403600:	41 57                	push   %r15
  403602:	49 89 c8             	mov    %rcx,%r8
    tests_define_accessors();
  403605:	45 31 ff             	xor    %r15d,%r15d
{
  403608:	41 56                	push   %r14
    if (!fc_solve_check_and_add_state(
  40360a:	49 89 d6             	mov    %rdx,%r14
  40360d:	41 55                	push   %r13
  40360f:	41 54                	push   %r12
  403611:	49 89 f4             	mov    %rsi,%r12
  403614:	55                   	push   %rbp
  403615:	53                   	push   %rbx
  403616:	48 83 ec 58          	sub    $0x58,%rsp
    tests_define_accessors();
  40361a:	4c 8b 2f             	mov    (%rdi),%r13
{
  40361d:	48 89 7c 24 20       	mov    %rdi,0x20(%rsp)
        const fcs_card card = fcs_freecell_card(state, fc);
  403622:	47 0f b6 54 3c 40    	movzbl 0x40(%r12,%r15,1),%r10d
  403628:	44 89 7c 24 18       	mov    %r15d,0x18(%rsp)
        if (fcs_card_is_empty(card))
  40362d:	45 84 d2             	test   %r10b,%r10b
  403630:	75 1e                	jne    403650 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x50>
  403632:	49 83 c7 01          	add    $0x1,%r15
    for (int fc = 0; fc < LOCAL_FREECELLS_NUM; fc++)
  403636:	49 83 ff 04          	cmp    $0x4,%r15
  40363a:	75 e6                	jne    403622 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x22>
}
  40363c:	48 83 c4 58          	add    $0x58,%rsp
  403640:	5b                   	pop    %rbx
  403641:	5d                   	pop    %rbp
  403642:	41 5c                	pop    %r12
  403644:	41 5d                	pop    %r13
  403646:	41 5e                	pop    %r14
  403648:	41 5f                	pop    %r15
  40364a:	c3                   	retq   
  40364b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  403650:	49 0f be c2          	movsbq %r10b,%rax
  403654:	4c 89 7c 24 28       	mov    %r15,0x28(%rsp)
        if (fcs_card_is_empty(card))
  403659:	31 db                	xor    %ebx,%ebx
  40365b:	4d 89 ef             	mov    %r13,%r15
  40365e:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  403663:	49 8d ad 00 01 00 00 	lea    0x100(%r13),%rbp
  40366a:	4c 89 f0             	mov    %r14,%rax
  40366d:	4d 89 c5             	mov    %r8,%r13
  403670:	4d 89 e6             	mov    %r12,%r14
  403673:	44 88 54 24 1f       	mov    %r10b,0x1f(%rsp)
  403678:	49 89 c4             	mov    %rax,%r12
  40367b:	eb 7f                	jmp    4036fc <fc_solve_sfs_atomic_move_freecell_card_to_parent+0xfc>
  40367d:	0f 1f 00             	nopl   (%rax)
        if (HT_FIELD(hard_thread, allocated_from_list))
  403680:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
  403685:	80 b9 18 05 00 00 00 	cmpb   $0x0,0x518(%rcx)
  40368c:	0f 84 7e 02 00 00    	je     403910 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x310>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  403692:	48 8b 91 b0 00 00 00 	mov    0xb0(%rcx),%rdx
  403699:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  40369e:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  4036a1:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  4036a6:	48 89 81 b0 00 00 00 	mov    %rax,0xb0(%rcx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  4036ad:	48 8b 54 24 40       	mov    0x40(%rsp),%rdx
    if ((!((list->num_states + (list->states != NULL)) &
  4036b2:	49 8b 45 08          	mov    0x8(%r13),%rax
  4036b6:	31 f6                	xor    %esi,%esi
  4036b8:	49 8b 7d 00          	mov    0x0(%r13),%rdi
  4036bc:	48 85 c0             	test   %rax,%rax
  4036bf:	40 0f 95 c6          	setne  %sil
  4036c3:	48 01 fe             	add    %rdi,%rsi
  4036c6:	40 f6 c6 0f          	test   $0xf,%sil
  4036ca:	0f 84 10 02 00 00    	je     4038e0 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x2e0>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  4036d0:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
  4036d4:	48 c1 e7 04          	shl    $0x4,%rdi
  4036d8:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4036dc:	48 01 f8             	add    %rdi,%rax
  4036df:	49 89 4d 00          	mov    %rcx,0x0(%r13)
  4036e3:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4036e7:	48 89 10             	mov    %rdx,(%rax)
  4036ea:	48 83 c3 01          	add    $0x1,%rbx
  4036ee:	48 83 ed 80          	sub    $0xffffffffffffff80,%rbp
        for (int ds = 0; ds < LOCAL_STACKS_NUM; ds++)
  4036f2:	48 83 fb 08          	cmp    $0x8,%rbx
  4036f6:	0f 84 c4 01 00 00    	je     4038c0 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x2c0>
            var_AUTO(dest_col, fcs_state_get_col(state, ds));
  4036fc:	49 8b 14 de          	mov    (%r14,%rbx,8),%rdx
  403700:	89 d9                	mov    %ebx,%ecx
            const_AUTO(l, fcs_col_len(dest_col));
  403702:	0f be 02             	movsbl (%rdx),%eax
            if (!l)
  403705:	84 c0                	test   %al,%al
  403707:	74 e1                	je     4036ea <fc_solve_sfs_atomic_move_freecell_card_to_parent+0xea>
            const fcs_card dest_card = fcs_col_get_card(dest_col, l - 1);
  403709:	83 e8 01             	sub    $0x1,%eax
            if (!fcs_is_parent_card(card, dest_card))
  40370c:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
            const fcs_card dest_card = fcs_col_get_card(dest_col, l - 1);
  403711:	48 98                	cltq   
  403713:	48 0f be 44 02 01    	movsbq 0x1(%rdx,%rax,1),%rax
  403719:	48 c1 e0 06          	shl    $0x6,%rax
            if (!fcs_is_parent_card(card, dest_card))
  40371d:	80 bc 38 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rax,%rdi,1)
  403724:	00 
  403725:	74 c3                	je     4036ea <fc_solve_sfs_atomic_move_freecell_card_to_parent+0xea>
                (instance->list_of_vacant_states != NULL)))
  403727:	49 8b 97 b0 00 00 00 	mov    0xb0(%r15),%rdx
  40372e:	48 85 d2             	test   %rdx,%rdx
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  403731:	41 0f 95 87 18 05 00 	setne  0x518(%r15)
  403738:	00 
  403739:	0f 84 21 01 00 00    	je     403860 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x260>
            FCS_S_NEXT(instance->list_of_vacant_states);
  40373f:	48 8b 42 48          	mov    0x48(%rdx),%rax
        instance->list_of_vacant_states =
  403743:	49 89 87 b0 00 00 00 	mov    %rax,0xb0(%r15)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  40374a:	c4 c1 7a 6f 16       	vmovdqu (%r14),%xmm2
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  40374f:	48 8d 42 48          	lea    0x48(%rdx),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  403753:	c4 e1 f9 6e ca       	vmovq  %rdx,%xmm1
  403758:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  40375e:	c5 f8 29 44 24 30    	vmovaps %xmm0,0x30(%rsp)
  403764:	c4 c1 7a 6f 34 24    	vmovdqu (%r12),%xmm6
  40376a:	c5 f8 11 12          	vmovups %xmm2,(%rdx)
  40376e:	c4 c1 7a 6f 5e 10    	vmovdqu 0x10(%r14),%xmm3
  403774:	c5 f8 11 5a 10       	vmovups %xmm3,0x10(%rdx)
  403779:	c4 c1 7a 6f 66 20    	vmovdqu 0x20(%r14),%xmm4
  40377f:	c5 f8 11 62 20       	vmovups %xmm4,0x20(%rdx)
  403784:	c4 c1 7a 6f 6e 30    	vmovdqu 0x30(%r14),%xmm5
  40378a:	c5 f8 11 6a 30       	vmovups %xmm5,0x30(%rdx)
  40378f:	49 8b 46 40          	mov    0x40(%r14),%rax
  403793:	c5 f8 11 72 48       	vmovups %xmm6,0x48(%rdx)
  403798:	48 89 42 40          	mov    %rax,0x40(%rdx)
  40379c:	49 8b 44 24 10       	mov    0x10(%r12),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  4037a1:	83 42 50 01          	addl   $0x1,0x50(%rdx)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  4037a5:	4c 89 72 48          	mov    %r14,0x48(%rdx)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  4037a9:	c6 42 56 00          	movb   $0x0,0x56(%rdx)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  4037ad:	48 89 42 58          	mov    %rax,0x58(%rdx)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  4037b1:	31 c0                	xor    %eax,%eax
  4037b3:	66 89 42 54          	mov    %ax,0x54(%rdx)
            my_copy_stack(ds);
  4037b7:	b8 01 00 00 00       	mov    $0x1,%eax
  4037bc:	d3 e0                	shl    %cl,%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  4037be:	c7 42 57 00 00 00 00 	movl   $0x0,0x57(%rdx)
  4037c5:	89 42 5c             	mov    %eax,0x5c(%rdx)
  4037c8:	48 63 c1             	movslq %ecx,%rax
  4037cb:	48 8b 34 c2          	mov    (%rdx,%rax,8),%rsi
  4037cf:	0f be 0e             	movsbl (%rsi),%ecx
  4037d2:	83 c1 01             	add    $0x1,%ecx
  4037d5:	48 63 c9             	movslq %ecx,%rcx
  4037d8:	48 83 f9 08          	cmp    $0x8,%rcx
  4037dc:	0f 83 be 00 00 00    	jae    4038a0 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x2a0>
  4037e2:	f6 c1 04             	test   $0x4,%cl
  4037e5:	0f 85 95 01 00 00    	jne    403980 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x380>
  4037eb:	48 85 c9             	test   %rcx,%rcx
  4037ee:	74 0f                	je     4037ff <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x1ff>
  4037f0:	0f b6 16             	movzbl (%rsi),%edx
  4037f3:	88 55 00             	mov    %dl,0x0(%rbp)
  4037f6:	f6 c1 02             	test   $0x2,%cl
  4037f9:	0f 85 a7 01 00 00    	jne    4039a6 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x3a6>
  4037ff:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
    fcs_col_push_card(col, card);
  403804:	0f b6 74 24 1f       	movzbl 0x1f(%rsp),%esi
  403809:	48 89 2c c2          	mov    %rbp,(%rdx,%rax,8)
            fcs_empty_freecell(new_state_key, fc);
  40380d:	48 63 44 24 18       	movslq 0x18(%rsp),%rax
  403812:	c6 44 02 40 00       	movb   $0x0,0x40(%rdx,%rax,1)
  403817:	48 0f be 45 00       	movsbq 0x0(%rbp),%rax
  40381c:	8d 50 01             	lea    0x1(%rax),%edx
  40381f:	88 55 00             	mov    %dl,0x0(%rbp)
    if (!fc_solve_check_and_add_state(
  403822:	48 8d 54 24 40       	lea    0x40(%rsp),%rdx
  403827:	40 88 74 05 01       	mov    %sil,0x1(%rbp,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  40382c:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  403831:	48 8d 74 24 30       	lea    0x30(%rsp),%rsi
    const_SLOT(hard_thread, soft_thread);
  403836:	48 8b 08             	mov    (%rax),%rcx
    if (!fc_solve_check_and_add_state(
  403839:	48 89 cf             	mov    %rcx,%rdi
  40383c:	48 89 4c 24 10       	mov    %rcx,0x10(%rsp)
  403841:	e8 2a e3 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  403846:	84 c0                	test   %al,%al
  403848:	0f 84 32 fe ff ff    	je     403680 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x80>
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  40384e:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  403853:	e9 5a fe ff ff       	jmpq   4036b2 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0xb2>
  403858:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40385f:	00 
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  403860:	49 8b 97 e8 00 00 00 	mov    0xe8(%r15),%rdx
  403867:	49 8b 87 e0 00 00 00 	mov    0xe0(%r15),%rax
  40386e:	48 29 d0             	sub    %rdx,%rax
  403871:	48 83 f8 5f          	cmp    $0x5f,%rax
  403875:	0f 86 b5 00 00 00    	jbe    403930 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x330>
        allocator->rollback_ptr = allocator->ptr;
  40387b:	49 89 97 f0 00 00 00 	mov    %rdx,0xf0(%r15)
    allocator->ptr += how_much;
  403882:	48 8d 42 60          	lea    0x60(%rdx),%rax
  403886:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
  40388d:	e9 b8 fe ff ff       	jmpq   40374a <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x14a>
  403892:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403899:	00 00 00 00 
  40389d:	0f 1f 00             	nopl   (%rax)
            my_copy_stack(ds);
  4038a0:	48 8b 54 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdx
  4038a5:	48 89 ef             	mov    %rbp,%rdi
  4038a8:	48 89 54 0d f8       	mov    %rdx,-0x8(%rbp,%rcx,1)
  4038ad:	48 83 e9 01          	sub    $0x1,%rcx
  4038b1:	48 c1 e9 03          	shr    $0x3,%rcx
  4038b5:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4038b8:	e9 42 ff ff ff       	jmpq   4037ff <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x1ff>
  4038bd:	0f 1f 00             	nopl   (%rax)
  4038c0:	4c 89 e0             	mov    %r12,%rax
  4038c3:	4d 89 e8             	mov    %r13,%r8
  4038c6:	4d 89 f4             	mov    %r14,%r12
  4038c9:	4d 89 fd             	mov    %r15,%r13
  4038cc:	49 89 c6             	mov    %rax,%r14
  4038cf:	4c 8b 7c 24 28       	mov    0x28(%rsp),%r15
  4038d4:	e9 59 fd ff ff       	jmpq   403632 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x32>
  4038d9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  4038e0:	48 83 c6 10          	add    $0x10,%rsi
  4038e4:	48 89 c7             	mov    %rax,%rdi
  4038e7:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  4038ec:	48 c1 e6 04          	shl    $0x4,%rsi
  4038f0:	e8 7b d8 ff ff       	callq  401170 <realloc@plt>
  4038f5:	49 8b 7d 00          	mov    0x0(%r13),%rdi
        list->states =
  4038f9:	49 89 45 08          	mov    %rax,0x8(%r13)
  4038fd:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  403902:	e9 c9 fd ff ff       	jmpq   4036d0 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0xd0>
  403907:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40390e:	00 00 
    allocator->ptr = allocator->rollback_ptr;
  403910:	48 8b 81 f0 00 00 00 	mov    0xf0(%rcx),%rax
  403917:	48 89 81 e8 00 00 00 	mov    %rax,0xe8(%rcx)
  40391e:	e9 8a fd ff ff       	jmpq   4036ad <fc_solve_sfs_atomic_move_freecell_card_to_parent+0xad>
  403923:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40392a:	00 00 00 00 
  40392e:	66 90                	xchg   %ax,%ax
    char *const new_data = meta_request_new_buffer(allocator->meta);
  403930:	49 8b 97 f8 00 00 00 	mov    0xf8(%r15),%rdx
    char *const ret = meta_alloc->recycle_bin;
  403937:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40393a:	48 85 c0             	test   %rax,%rax
  40393d:	74 53                	je     403992 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x392>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40393f:	48 8b 30             	mov    (%rax),%rsi
  403942:	48 89 32             	mov    %rsi,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  403945:	49 8b 97 d8 00 00 00 	mov    0xd8(%r15),%rdx
  40394c:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40394f:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  403953:	49 89 87 d8 00 00 00 	mov    %rax,0xd8(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40395a:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  403960:	49 89 97 f0 00 00 00 	mov    %rdx,0xf0(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  403967:	49 89 87 e0 00 00 00 	mov    %rax,0xe0(%r15)
  40396e:	e9 0f ff ff ff       	jmpq   403882 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x282>
  403973:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40397a:	00 00 00 00 
  40397e:	66 90                	xchg   %ax,%ax
  403980:	8b 16                	mov    (%rsi),%edx
  403982:	89 55 00             	mov    %edx,0x0(%rbp)
  403985:	8b 54 0e fc          	mov    -0x4(%rsi,%rcx,1),%edx
  403989:	89 54 0d fc          	mov    %edx,-0x4(%rbp,%rcx,1)
  40398d:	e9 6d fe ff ff       	jmpq   4037ff <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x1ff>
        return malloc(ALLOCED_SIZE);
  403992:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  403997:	89 5c 24 10          	mov    %ebx,0x10(%rsp)
  40399b:	e8 50 d7 ff ff       	callq  4010f0 <malloc@plt>
  4039a0:	8b 4c 24 10          	mov    0x10(%rsp),%ecx
  4039a4:	eb 9f                	jmp    403945 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x345>
  4039a6:	0f b7 54 0e fe       	movzwl -0x2(%rsi,%rcx,1),%edx
  4039ab:	66 89 54 0d fe       	mov    %dx,-0x2(%rbp,%rcx,1)
  4039b0:	e9 4a fe ff ff       	jmpq   4037ff <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x1ff>
  4039b5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4039bc:	00 00 00 00 

00000000004039c0 <fc_solve_sfs_atomic_move_card_to_freecell>:
    if (num_vacant_freecells == 0)
  4039c0:	80 bf e4 01 00 00 00 	cmpb   $0x0,0x1e4(%rdi)
  4039c7:	0f 84 43 03 00 00    	je     403d10 <fc_solve_sfs_atomic_move_card_to_freecell+0x350>
{
  4039cd:	41 57                	push   %r15
  4039cf:	41 56                	push   %r14
  4039d1:	41 55                	push   %r13
  4039d3:	41 54                	push   %r12
  4039d5:	55                   	push   %rbp
  4039d6:	53                   	push   %rbx
  4039d7:	48 83 ec 48          	sub    $0x48,%rsp
        if (fcs_freecell_is_empty(state, ds))
  4039db:	80 7e 40 00          	cmpb   $0x0,0x40(%rsi)
  4039df:	0f 84 8a 03 00 00    	je     403d6f <fc_solve_sfs_atomic_move_card_to_freecell+0x3af>
  4039e5:	80 7e 41 00          	cmpb   $0x0,0x41(%rsi)
  4039e9:	0f 84 87 03 00 00    	je     403d76 <fc_solve_sfs_atomic_move_card_to_freecell+0x3b6>
  4039ef:	80 7e 42 00          	cmpb   $0x0,0x42(%rsi)
  4039f3:	0f 84 87 03 00 00    	je     403d80 <fc_solve_sfs_atomic_move_card_to_freecell+0x3c0>
    for (ds = 0; ds < LOCAL_FREECELLS_NUM; ds++)
  4039f9:	31 c0                	xor    %eax,%eax
  4039fb:	80 7e 43 00          	cmpb   $0x0,0x43(%rsi)
  4039ff:	0f 95 c0             	setne  %al
  403a02:	83 c0 03             	add    $0x3,%eax
    tests_define_accessors();
  403a05:	4c 8b 37             	mov    (%rdi),%r14
        fcs_put_card_in_freecell(new_state_key, ds, card);
  403a08:	48 98                	cltq   
  403a0a:	49 89 cd             	mov    %rcx,%r13
  403a0d:	49 89 d4             	mov    %rdx,%r12
  403a10:	48 89 f5             	mov    %rsi,%rbp
  403a13:	48 89 7c 24 10       	mov    %rdi,0x10(%rsp)
    tests_define_accessors();
  403a18:	45 31 ff             	xor    %r15d,%r15d
        fcs_put_card_in_freecell(new_state_key, ds, card);
  403a1b:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  403a20:	49 8d 9e 00 01 00 00 	lea    0x100(%r14),%rbx
  403a27:	e9 94 01 00 00       	jmpq   403bc0 <fc_solve_sfs_atomic_move_card_to_freecell+0x200>
  403a2c:	0f 1f 40 00          	nopl   0x0(%rax)
            FCS_S_NEXT(instance->list_of_vacant_states);
  403a30:	49 8b 40 48          	mov    0x48(%r8),%rax
        instance->list_of_vacant_states =
  403a34:	49 89 86 b0 00 00 00 	mov    %rax,0xb0(%r14)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  403a3b:	c5 fa 6f 55 00       	vmovdqu 0x0(%rbp),%xmm2
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  403a40:	49 8d 40 48          	lea    0x48(%r8),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  403a44:	c4 c1 f9 6e c8       	vmovq  %r8,%xmm1
  403a49:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  403a4f:	c5 f8 29 44 24 20    	vmovaps %xmm0,0x20(%rsp)
  403a55:	c4 c1 7a 6f 34 24    	vmovdqu (%r12),%xmm6
  403a5b:	c4 c1 78 11 10       	vmovups %xmm2,(%r8)
  403a60:	c5 fa 6f 5d 10       	vmovdqu 0x10(%rbp),%xmm3
  403a65:	c4 c1 78 11 58 10    	vmovups %xmm3,0x10(%r8)
  403a6b:	c5 fa 6f 65 20       	vmovdqu 0x20(%rbp),%xmm4
  403a70:	c4 c1 78 11 60 20    	vmovups %xmm4,0x20(%r8)
  403a76:	c5 fa 6f 6d 30       	vmovdqu 0x30(%rbp),%xmm5
  403a7b:	c4 c1 78 11 68 30    	vmovups %xmm5,0x30(%r8)
  403a81:	48 8b 45 40          	mov    0x40(%rbp),%rax
  403a85:	c4 c1 78 11 70 48    	vmovups %xmm6,0x48(%r8)
  403a8b:	49 89 40 40          	mov    %rax,0x40(%r8)
  403a8f:	49 8b 44 24 10       	mov    0x10(%r12),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  403a94:	41 83 40 50 01       	addl   $0x1,0x50(%r8)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  403a99:	49 89 68 48          	mov    %rbp,0x48(%r8)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  403a9d:	41 c6 40 56 00       	movb   $0x0,0x56(%r8)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  403aa2:	49 89 40 58          	mov    %rax,0x58(%r8)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  403aa6:	31 c0                	xor    %eax,%eax
  403aa8:	66 41 89 40 54       	mov    %ax,0x54(%r8)
        my_copy_stack(stack_idx);
  403aad:	b8 01 00 00 00       	mov    $0x1,%eax
  403ab2:	d3 e0                	shl    %cl,%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  403ab4:	41 c7 40 57 00 00 00 	movl   $0x0,0x57(%r8)
  403abb:	00 
  403abc:	41 89 40 5c          	mov    %eax,0x5c(%r8)
  403ac0:	48 63 c1             	movslq %ecx,%rax
  403ac3:	49 8b 34 c0          	mov    (%r8,%rax,8),%rsi
  403ac7:	0f be 0e             	movsbl (%rsi),%ecx
  403aca:	83 c1 01             	add    $0x1,%ecx
  403acd:	48 63 c9             	movslq %ecx,%rcx
  403ad0:	48 83 f9 08          	cmp    $0x8,%rcx
  403ad4:	0f 83 56 01 00 00    	jae    403c30 <fc_solve_sfs_atomic_move_card_to_freecell+0x270>
  403ada:	f6 c1 04             	test   $0x4,%cl
  403add:	0f 85 5d 02 00 00    	jne    403d40 <fc_solve_sfs_atomic_move_card_to_freecell+0x380>
  403ae3:	48 85 c9             	test   %rcx,%rcx
  403ae6:	74 0f                	je     403af7 <fc_solve_sfs_atomic_move_card_to_freecell+0x137>
  403ae8:	0f b6 3e             	movzbl (%rsi),%edi
  403aeb:	40 88 3b             	mov    %dil,(%rbx)
  403aee:	f6 c1 02             	test   $0x2,%cl
  403af1:	0f 85 69 02 00 00    	jne    403d60 <fc_solve_sfs_atomic_move_card_to_freecell+0x3a0>
  403af7:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
    if (!fc_solve_check_and_add_state(
  403afc:	48 8d 74 24 20       	lea    0x20(%rsp),%rsi
        fcs_put_card_in_freecell(new_state_key, ds, card);
  403b01:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
        my_copy_stack(stack_idx);
  403b06:	48 89 1c c1          	mov    %rbx,(%rcx,%rax,8)
    fcs_col_pop_top(col);
  403b0a:	0f b6 03             	movzbl (%rbx),%eax
  403b0d:	83 e8 01             	sub    $0x1,%eax
  403b10:	88 03                	mov    %al,(%rbx)
  403b12:	48 0f be c0          	movsbq %al,%rax
  403b16:	c6 44 03 01 00       	movb   $0x0,0x1(%rbx,%rax,1)
        fcs_put_card_in_freecell(new_state_key, ds, card);
  403b1b:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403b20:	88 54 38 40          	mov    %dl,0x40(%rax,%rdi,1)
    const_SLOT(hard_thread, soft_thread);
  403b24:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  403b29:	48 8d 54 24 30       	lea    0x30(%rsp),%rdx
    const_SLOT(hard_thread, soft_thread);
  403b2e:	48 8b 08             	mov    (%rax),%rcx
    if (!fc_solve_check_and_add_state(
  403b31:	48 89 cf             	mov    %rcx,%rdi
  403b34:	48 89 0c 24          	mov    %rcx,(%rsp)
  403b38:	e8 33 e0 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  403b3d:	84 c0                	test   %al,%al
  403b3f:	0f 85 0b 01 00 00    	jne    403c50 <fc_solve_sfs_atomic_move_card_to_freecell+0x290>
        if (HT_FIELD(hard_thread, allocated_from_list))
  403b45:	48 8b 0c 24          	mov    (%rsp),%rcx
  403b49:	80 b9 18 05 00 00 00 	cmpb   $0x0,0x518(%rcx)
  403b50:	0f 84 3a 01 00 00    	je     403c90 <fc_solve_sfs_atomic_move_card_to_freecell+0x2d0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  403b56:	48 8b 91 b0 00 00 00 	mov    0xb0(%rcx),%rdx
  403b5d:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  403b62:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  403b65:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403b6a:	48 89 81 b0 00 00 00 	mov    %rax,0xb0(%rcx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  403b71:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
    if ((!((list->num_states + (list->states != NULL)) &
  403b76:	49 8b 45 08          	mov    0x8(%r13),%rax
  403b7a:	31 f6                	xor    %esi,%esi
  403b7c:	49 8b 7d 00          	mov    0x0(%r13),%rdi
  403b80:	48 85 c0             	test   %rax,%rax
  403b83:	40 0f 95 c6          	setne  %sil
  403b87:	48 01 fe             	add    %rdi,%rsi
  403b8a:	40 f6 c6 0f          	test   $0xf,%sil
  403b8e:	0f 84 cc 00 00 00    	je     403c60 <fc_solve_sfs_atomic_move_card_to_freecell+0x2a0>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  403b94:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
  403b98:	48 c1 e7 04          	shl    $0x4,%rdi
  403b9c:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  403ba0:	48 01 f8             	add    %rdi,%rax
  403ba3:	49 89 4d 00          	mov    %rcx,0x0(%r13)
  403ba7:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  403bab:	48 89 10             	mov    %rdx,(%rax)
  403bae:	49 83 c7 01          	add    $0x1,%r15
  403bb2:	48 83 eb 80          	sub    $0xffffffffffffff80,%rbx
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  403bb6:	49 83 ff 08          	cmp    $0x8,%r15
  403bba:	0f 84 f0 00 00 00    	je     403cb0 <fc_solve_sfs_atomic_move_card_to_freecell+0x2f0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  403bc0:	4a 8b 54 fd 00       	mov    0x0(%rbp,%r15,8),%rdx
  403bc5:	44 89 f9             	mov    %r15d,%ecx
        const int cards_num = fcs_col_len(col);
  403bc8:	0f be 02             	movsbl (%rdx),%eax
        if (cards_num <= num_cards_in_col_threshold)
  403bcb:	85 c0                	test   %eax,%eax
  403bcd:	7e df                	jle    403bae <fc_solve_sfs_atomic_move_card_to_freecell+0x1ee>
                (instance->list_of_vacant_states != NULL)))
  403bcf:	4d 8b 86 b0 00 00 00 	mov    0xb0(%r14),%r8
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  403bd6:	83 e8 01             	sub    $0x1,%eax
  403bd9:	48 98                	cltq   
  403bdb:	0f b6 54 02 01       	movzbl 0x1(%rdx,%rax,1),%edx
  403be0:	4d 85 c0             	test   %r8,%r8
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  403be3:	41 0f 95 86 18 05 00 	setne  0x518(%r14)
  403bea:	00 
  403beb:	0f 85 3f fe ff ff    	jne    403a30 <fc_solve_sfs_atomic_move_card_to_freecell+0x70>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  403bf1:	4d 8b 86 e8 00 00 00 	mov    0xe8(%r14),%r8
  403bf8:	49 8b 86 e0 00 00 00 	mov    0xe0(%r14),%rax
  403bff:	4c 29 c0             	sub    %r8,%rax
  403c02:	48 83 f8 5f          	cmp    $0x5f,%rax
  403c06:	0f 86 b4 00 00 00    	jbe    403cc0 <fc_solve_sfs_atomic_move_card_to_freecell+0x300>
        allocator->rollback_ptr = allocator->ptr;
  403c0c:	4d 89 86 f0 00 00 00 	mov    %r8,0xf0(%r14)
    allocator->ptr += how_much;
  403c13:	49 8d 40 60          	lea    0x60(%r8),%rax
  403c17:	49 89 86 e8 00 00 00 	mov    %rax,0xe8(%r14)
  403c1e:	e9 18 fe ff ff       	jmpq   403a3b <fc_solve_sfs_atomic_move_card_to_freecell+0x7b>
  403c23:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403c2a:	00 00 00 00 
  403c2e:	66 90                	xchg   %ax,%ax
        my_copy_stack(stack_idx);
  403c30:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  403c35:	48 89 7c 0b f8       	mov    %rdi,-0x8(%rbx,%rcx,1)
  403c3a:	48 83 e9 01          	sub    $0x1,%rcx
  403c3e:	48 89 df             	mov    %rbx,%rdi
  403c41:	48 c1 e9 03          	shr    $0x3,%rcx
  403c45:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  403c48:	e9 aa fe ff ff       	jmpq   403af7 <fc_solve_sfs_atomic_move_card_to_freecell+0x137>
  403c4d:	0f 1f 00             	nopl   (%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  403c50:	48 8b 54 24 20       	mov    0x20(%rsp),%rdx
  403c55:	e9 1c ff ff ff       	jmpq   403b76 <fc_solve_sfs_atomic_move_card_to_freecell+0x1b6>
  403c5a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  403c60:	48 83 c6 10          	add    $0x10,%rsi
  403c64:	48 89 c7             	mov    %rax,%rdi
  403c67:	48 89 14 24          	mov    %rdx,(%rsp)
  403c6b:	48 c1 e6 04          	shl    $0x4,%rsi
  403c6f:	e8 fc d4 ff ff       	callq  401170 <realloc@plt>
  403c74:	49 8b 7d 00          	mov    0x0(%r13),%rdi
        list->states =
  403c78:	49 89 45 08          	mov    %rax,0x8(%r13)
  403c7c:	48 8b 14 24          	mov    (%rsp),%rdx
  403c80:	e9 0f ff ff ff       	jmpq   403b94 <fc_solve_sfs_atomic_move_card_to_freecell+0x1d4>
  403c85:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403c8c:	00 00 00 00 
    allocator->ptr = allocator->rollback_ptr;
  403c90:	48 8b 81 f0 00 00 00 	mov    0xf0(%rcx),%rax
  403c97:	48 89 81 e8 00 00 00 	mov    %rax,0xe8(%rcx)
  403c9e:	e9 ce fe ff ff       	jmpq   403b71 <fc_solve_sfs_atomic_move_card_to_freecell+0x1b1>
  403ca3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403caa:	00 00 00 00 
  403cae:	66 90                	xchg   %ax,%ax
}
  403cb0:	48 83 c4 48          	add    $0x48,%rsp
  403cb4:	5b                   	pop    %rbx
  403cb5:	5d                   	pop    %rbp
  403cb6:	41 5c                	pop    %r12
  403cb8:	41 5d                	pop    %r13
  403cba:	41 5e                	pop    %r14
  403cbc:	41 5f                	pop    %r15
  403cbe:	c3                   	retq   
  403cbf:	90                   	nop
    char *const new_data = meta_request_new_buffer(allocator->meta);
  403cc0:	49 8b b6 f8 00 00 00 	mov    0xf8(%r14),%rsi
    char *const ret = meta_alloc->recycle_bin;
  403cc7:	48 8b 06             	mov    (%rsi),%rax
    if (ret)
  403cca:	48 85 c0             	test   %rax,%rax
  403ccd:	74 51                	je     403d20 <fc_solve_sfs_atomic_move_card_to_freecell+0x360>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  403ccf:	48 8b 38             	mov    (%rax),%rdi
  403cd2:	48 89 3e             	mov    %rdi,(%rsi)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  403cd5:	49 8b b6 d8 00 00 00 	mov    0xd8(%r14),%rsi
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  403cdc:	4c 8d 40 08          	lea    0x8(%rax),%r8
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  403ce0:	48 89 30             	mov    %rsi,(%rax)
    allocator->old_list = new_data;
  403ce3:	49 89 86 d8 00 00 00 	mov    %rax,0xd8(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  403cea:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  403cf0:	4d 89 86 f0 00 00 00 	mov    %r8,0xf0(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  403cf7:	49 89 86 e0 00 00 00 	mov    %rax,0xe0(%r14)
  403cfe:	e9 10 ff ff ff       	jmpq   403c13 <fc_solve_sfs_atomic_move_card_to_freecell+0x253>
  403d03:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403d0a:	00 00 00 00 
  403d0e:	66 90                	xchg   %ax,%ax
  403d10:	c3                   	retq   
  403d11:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403d18:	00 00 00 00 
  403d1c:	0f 1f 40 00          	nopl   0x0(%rax)
        return malloc(ALLOCED_SIZE);
  403d20:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  403d25:	88 14 24             	mov    %dl,(%rsp)
  403d28:	44 89 7c 24 1c       	mov    %r15d,0x1c(%rsp)
  403d2d:	e8 be d3 ff ff       	callq  4010f0 <malloc@plt>
  403d32:	8b 4c 24 1c          	mov    0x1c(%rsp),%ecx
  403d36:	0f b6 14 24          	movzbl (%rsp),%edx
  403d3a:	eb 99                	jmp    403cd5 <fc_solve_sfs_atomic_move_card_to_freecell+0x315>
  403d3c:	0f 1f 40 00          	nopl   0x0(%rax)
        my_copy_stack(stack_idx);
  403d40:	8b 3e                	mov    (%rsi),%edi
  403d42:	89 3b                	mov    %edi,(%rbx)
  403d44:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  403d48:	89 74 0b fc          	mov    %esi,-0x4(%rbx,%rcx,1)
  403d4c:	e9 a6 fd ff ff       	jmpq   403af7 <fc_solve_sfs_atomic_move_card_to_freecell+0x137>
  403d51:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403d58:	00 00 00 00 
  403d5c:	0f 1f 40 00          	nopl   0x0(%rax)
  403d60:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  403d65:	66 89 74 0b fe       	mov    %si,-0x2(%rbx,%rcx,1)
  403d6a:	e9 88 fd ff ff       	jmpq   403af7 <fc_solve_sfs_atomic_move_card_to_freecell+0x137>
    for (ds = 0; ds < LOCAL_FREECELLS_NUM; ds++)
  403d6f:	31 c0                	xor    %eax,%eax
  403d71:	e9 8f fc ff ff       	jmpq   403a05 <fc_solve_sfs_atomic_move_card_to_freecell+0x45>
  403d76:	b8 01 00 00 00       	mov    $0x1,%eax
  403d7b:	e9 85 fc ff ff       	jmpq   403a05 <fc_solve_sfs_atomic_move_card_to_freecell+0x45>
  403d80:	b8 02 00 00 00       	mov    $0x2,%eax
  403d85:	e9 7b fc ff ff       	jmpq   403a05 <fc_solve_sfs_atomic_move_card_to_freecell+0x45>
  403d8a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

0000000000403d90 <fc_solve_sfs_atomic_move_card_to_parent>:
{
  403d90:	41 57                	push   %r15
    if (!fc_solve_check_and_add_state(
  403d92:	49 89 d1             	mov    %rdx,%r9
    MOVE_FUNCS__define_common();
  403d95:	45 31 ff             	xor    %r15d,%r15d
  403d98:	49 89 c8             	mov    %rcx,%r8
{
  403d9b:	41 56                	push   %r14
  403d9d:	41 55                	push   %r13
  403d9f:	41 54                	push   %r12
  403da1:	55                   	push   %rbp
  403da2:	48 89 f5             	mov    %rsi,%rbp
  403da5:	53                   	push   %rbx
  403da6:	48 83 ec 68          	sub    $0x68,%rsp
    MOVE_FUNCS__define_common();
  403daa:	4c 8b 37             	mov    (%rdi),%r14
{
  403dad:	48 89 7c 24 30       	mov    %rdi,0x30(%rsp)
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  403db2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403db9:	00 00 00 00 
  403dbd:	0f 1f 00             	nopl   (%rax)
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  403dc0:	4a 8b 54 fd 00       	mov    0x0(%rbp,%r15,8),%rdx
  403dc5:	4d 63 ef             	movslq %r15d,%r13
        const int cards_num = fcs_col_len(col);
  403dc8:	0f be 02             	movsbl (%rdx),%eax
        if (cards_num <= num_cards_in_col_threshold)
  403dcb:	85 c0                	test   %eax,%eax
  403dcd:	0f 8e 80 02 00 00    	jle    404053 <fc_solve_sfs_atomic_move_card_to_parent+0x2c3>
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  403dd3:	83 e8 01             	sub    $0x1,%eax
            copy_two_stacks(stack_idx, ds);
  403dd6:	bf 01 00 00 00       	mov    $0x1,%edi
  403ddb:	44 89 f9             	mov    %r15d,%ecx
  403dde:	4c 89 6c 24 08       	mov    %r13,0x8(%rsp)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  403de3:	48 98                	cltq   
  403de5:	4d 89 fc             	mov    %r15,%r12
            copy_two_stacks(stack_idx, ds);
  403de8:	d3 e7                	shl    %cl,%edi
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  403dea:	48 0f be 44 02 01    	movsbq 0x1(%rdx,%rax,1),%rax
  403df0:	49 c1 e4 07          	shl    $0x7,%r12
            copy_two_stacks(stack_idx, ds);
  403df4:	89 7c 24 28          	mov    %edi,0x28(%rsp)
  403df8:	31 db                	xor    %ebx,%ebx
  403dfa:	49 8d b6 00 01 00 00 	lea    0x100(%r14),%rsi
  403e01:	4d 89 cd             	mov    %r9,%r13
  403e04:	48 89 74 24 38       	mov    %rsi,0x38(%rsp)
  403e09:	49 01 f4             	add    %rsi,%r12
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  403e0c:	88 44 24 2f          	mov    %al,0x2f(%rsp)
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  403e10:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
  403e15:	e9 b9 01 00 00       	jmpq   403fd3 <fc_solve_sfs_atomic_move_card_to_parent+0x243>
  403e1a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            FCS_S_NEXT(instance->list_of_vacant_states);
  403e20:	48 8b 41 48          	mov    0x48(%rcx),%rax
        instance->list_of_vacant_states =
  403e24:	49 89 86 b0 00 00 00 	mov    %rax,0xb0(%r14)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  403e2b:	c5 fa 6f 55 00       	vmovdqu 0x0(%rbp),%xmm2
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  403e30:	48 8d 41 48          	lea    0x48(%rcx),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  403e34:	c4 e1 f9 6e c9       	vmovq  %rcx,%xmm1
  403e39:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  403e3f:	c5 f8 29 44 24 40    	vmovaps %xmm0,0x40(%rsp)
  403e45:	c4 c1 7a 6f 75 00    	vmovdqu 0x0(%r13),%xmm6
  403e4b:	c5 f8 11 11          	vmovups %xmm2,(%rcx)
  403e4f:	c5 fa 6f 5d 10       	vmovdqu 0x10(%rbp),%xmm3
  403e54:	c5 f8 11 59 10       	vmovups %xmm3,0x10(%rcx)
  403e59:	c5 fa 6f 65 20       	vmovdqu 0x20(%rbp),%xmm4
  403e5e:	c5 f8 11 61 20       	vmovups %xmm4,0x20(%rcx)
  403e63:	c5 fa 6f 6d 30       	vmovdqu 0x30(%rbp),%xmm5
  403e68:	c5 f8 11 69 30       	vmovups %xmm5,0x30(%rcx)
  403e6d:	48 8b 45 40          	mov    0x40(%rbp),%rax
  403e71:	c5 f8 11 71 48       	vmovups %xmm6,0x48(%rcx)
  403e76:	48 89 41 40          	mov    %rax,0x40(%rcx)
  403e7a:	49 8b 45 10          	mov    0x10(%r13),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  403e7e:	83 41 50 01          	addl   $0x1,0x50(%rcx)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  403e82:	48 89 69 48          	mov    %rbp,0x48(%rcx)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  403e86:	c6 41 56 00          	movb   $0x0,0x56(%rcx)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  403e8a:	48 89 41 58          	mov    %rax,0x58(%rcx)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  403e8e:	31 c0                	xor    %eax,%eax
  403e90:	66 89 41 54          	mov    %ax,0x54(%rcx)
            copy_two_stacks(stack_idx, ds);
  403e94:	8b 44 24 28          	mov    0x28(%rsp),%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  403e98:	c7 41 57 00 00 00 00 	movl   $0x0,0x57(%rcx)
  403e9f:	89 41 5c             	mov    %eax,0x5c(%rcx)
  403ea2:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  403ea7:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  403eab:	0f be 0e             	movsbl (%rsi),%ecx
  403eae:	83 c1 01             	add    $0x1,%ecx
  403eb1:	48 63 c9             	movslq %ecx,%rcx
  403eb4:	48 83 f9 08          	cmp    $0x8,%rcx
  403eb8:	0f 83 b2 01 00 00    	jae    404070 <fc_solve_sfs_atomic_move_card_to_parent+0x2e0>
  403ebe:	f6 c1 04             	test   $0x4,%cl
  403ec1:	0f 85 09 03 00 00    	jne    4041d0 <fc_solve_sfs_atomic_move_card_to_parent+0x440>
  403ec7:	48 85 c9             	test   %rcx,%rcx
  403eca:	74 10                	je     403edc <fc_solve_sfs_atomic_move_card_to_parent+0x14c>
  403ecc:	0f b6 06             	movzbl (%rsi),%eax
  403ecf:	41 88 04 24          	mov    %al,(%r12)
  403ed3:	f6 c1 02             	test   $0x2,%cl
  403ed6:	0f 85 26 03 00 00    	jne    404202 <fc_solve_sfs_atomic_move_card_to_parent+0x472>
  403edc:	4c 8b 54 24 48       	mov    0x48(%rsp),%r10
  403ee1:	4c 89 e1             	mov    %r12,%rcx
  403ee4:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  403ee9:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  403eee:	41 8b 72 14          	mov    0x14(%r10),%esi
  403ef2:	4c 89 24 c7          	mov    %r12,(%rdi,%rax,8)
  403ef6:	48 63 c2             	movslq %edx,%rax
  403ef9:	0f a3 d6             	bt     %edx,%esi
  403efc:	0f 83 9e 01 00 00    	jae    4040a0 <fc_solve_sfs_atomic_move_card_to_parent+0x310>
    fcs_col_pop_top(col);
  403f02:	0f b6 39             	movzbl (%rcx),%edi
  403f05:	4c 89 44 24 18       	mov    %r8,0x18(%rsp)
    fcs_col_push_card(col, card);
  403f0a:	0f b6 74 24 2f       	movzbl 0x2f(%rsp),%esi
    fcs_col_pop_top(col);
  403f0f:	8d 57 ff             	lea    -0x1(%rdi),%edx
  403f12:	88 11                	mov    %dl,(%rcx)
  403f14:	48 0f be d2          	movsbq %dl,%rdx
  403f18:	c6 44 11 01 00       	movb   $0x0,0x1(%rcx,%rdx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  403f1d:	48 8b 54 24 40       	mov    0x40(%rsp),%rdx
  403f22:	48 8b 14 c2          	mov    (%rdx,%rax,8),%rdx
    fcs_col_push_card(col, card);
  403f26:	48 0f be 02          	movsbq (%rdx),%rax
  403f2a:	8d 48 01             	lea    0x1(%rax),%ecx
  403f2d:	88 0a                	mov    %cl,(%rdx)
  403f2f:	40 88 74 02 01       	mov    %sil,0x1(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  403f34:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  403f39:	48 8d 54 24 50       	lea    0x50(%rsp),%rdx
  403f3e:	48 8d 74 24 40       	lea    0x40(%rsp),%rsi
    const_SLOT(hard_thread, soft_thread);
  403f43:	48 8b 08             	mov    (%rax),%rcx
    if (!fc_solve_check_and_add_state(
  403f46:	48 89 cf             	mov    %rcx,%rdi
  403f49:	48 89 4c 24 20       	mov    %rcx,0x20(%rsp)
  403f4e:	e8 1d dc ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  403f53:	4c 8b 44 24 18       	mov    0x18(%rsp),%r8
  403f58:	84 c0                	test   %al,%al
  403f5a:	0f 85 30 01 00 00    	jne    404090 <fc_solve_sfs_atomic_move_card_to_parent+0x300>
        if (HT_FIELD(hard_thread, allocated_from_list))
  403f60:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  403f65:	80 b9 18 05 00 00 00 	cmpb   $0x0,0x518(%rcx)
  403f6c:	0f 84 be 01 00 00    	je     404130 <fc_solve_sfs_atomic_move_card_to_parent+0x3a0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  403f72:	48 8b 91 b0 00 00 00 	mov    0xb0(%rcx),%rdx
  403f79:	48 8b 44 24 48       	mov    0x48(%rsp),%rax
  403f7e:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  403f81:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  403f86:	48 89 81 b0 00 00 00 	mov    %rax,0xb0(%rcx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  403f8d:	48 8b 54 24 50       	mov    0x50(%rsp),%rdx
    if ((!((list->num_states + (list->states != NULL)) &
  403f92:	49 8b 78 08          	mov    0x8(%r8),%rdi
  403f96:	31 f6                	xor    %esi,%esi
  403f98:	49 8b 00             	mov    (%r8),%rax
  403f9b:	48 85 ff             	test   %rdi,%rdi
  403f9e:	40 0f 95 c6          	setne  %sil
  403fa2:	48 01 c6             	add    %rax,%rsi
  403fa5:	40 f6 c6 0f          	test   $0xf,%sil
  403fa9:	0f 84 51 01 00 00    	je     404100 <fc_solve_sfs_atomic_move_card_to_parent+0x370>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  403faf:	48 8d 48 01          	lea    0x1(%rax),%rcx
  403fb3:	48 c1 e0 04          	shl    $0x4,%rax
  403fb7:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  403fbb:	48 8d 04 07          	lea    (%rdi,%rax,1),%rax
  403fbf:	49 89 08             	mov    %rcx,(%r8)
  403fc2:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  403fc6:	48 89 10             	mov    %rdx,(%rax)
  403fc9:	48 83 c3 01          	add    $0x1,%rbx
        for (int ds = 0; ds < LOCAL_STACKS_NUM; ds++)
  403fcd:	48 83 fb 08          	cmp    $0x8,%rbx
  403fd1:	74 7d                	je     404050 <fc_solve_sfs_atomic_move_card_to_parent+0x2c0>
  403fd3:	89 da                	mov    %ebx,%edx
            if (ds == stack_idx)
  403fd5:	41 39 df             	cmp    %ebx,%r15d
  403fd8:	74 ef                	je     403fc9 <fc_solve_sfs_atomic_move_card_to_parent+0x239>
            var_AUTO(dest_col, fcs_state_get_col(state, ds));
  403fda:	48 8b 4c dd 00       	mov    0x0(%rbp,%rbx,8),%rcx
            const int dest_cards_num = fcs_col_len(dest_col);
  403fdf:	0f be 01             	movsbl (%rcx),%eax
            if (!dest_cards_num)
  403fe2:	84 c0                	test   %al,%al
  403fe4:	74 e3                	je     403fc9 <fc_solve_sfs_atomic_move_card_to_parent+0x239>
                fcs_col_get_card(dest_col, fcs_col_len(dest_col) - 1);
  403fe6:	83 e8 01             	sub    $0x1,%eax
            if (!fcs_is_parent_card(card, dest_card))
  403fe9:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
                fcs_col_get_card(dest_col, fcs_col_len(dest_col) - 1);
  403fee:	48 98                	cltq   
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  403ff0:	48 0f be 44 01 01    	movsbq 0x1(%rcx,%rax,1),%rax
  403ff6:	48 c1 e0 06          	shl    $0x6,%rax
            if (!fcs_is_parent_card(card, dest_card))
  403ffa:	80 bc 38 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rax,%rdi,1)
  404001:	00 
  404002:	74 c5                	je     403fc9 <fc_solve_sfs_atomic_move_card_to_parent+0x239>
                (instance->list_of_vacant_states != NULL)))
  404004:	49 8b 8e b0 00 00 00 	mov    0xb0(%r14),%rcx
  40400b:	48 85 c9             	test   %rcx,%rcx
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  40400e:	41 0f 95 86 18 05 00 	setne  0x518(%r14)
  404015:	00 
  404016:	0f 85 04 fe ff ff    	jne    403e20 <fc_solve_sfs_atomic_move_card_to_parent+0x90>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  40401c:	49 8b 8e e8 00 00 00 	mov    0xe8(%r14),%rcx
  404023:	49 8b 86 e0 00 00 00 	mov    0xe0(%r14),%rax
  40402a:	48 29 c8             	sub    %rcx,%rax
  40402d:	48 83 f8 5f          	cmp    $0x5f,%rax
  404031:	0f 86 49 01 00 00    	jbe    404180 <fc_solve_sfs_atomic_move_card_to_parent+0x3f0>
        allocator->rollback_ptr = allocator->ptr;
  404037:	49 89 8e f0 00 00 00 	mov    %rcx,0xf0(%r14)
    allocator->ptr += how_much;
  40403e:	48 8d 41 60          	lea    0x60(%rcx),%rax
  404042:	49 89 86 e8 00 00 00 	mov    %rax,0xe8(%r14)
  404049:	e9 dd fd ff ff       	jmpq   403e2b <fc_solve_sfs_atomic_move_card_to_parent+0x9b>
  40404e:	66 90                	xchg   %ax,%ax
  404050:	4d 89 e9             	mov    %r13,%r9
  404053:	49 83 c7 01          	add    $0x1,%r15
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  404057:	49 83 ff 08          	cmp    $0x8,%r15
  40405b:	0f 85 5f fd ff ff    	jne    403dc0 <fc_solve_sfs_atomic_move_card_to_parent+0x30>
}
  404061:	48 83 c4 68          	add    $0x68,%rsp
  404065:	5b                   	pop    %rbx
  404066:	5d                   	pop    %rbp
  404067:	41 5c                	pop    %r12
  404069:	41 5d                	pop    %r13
  40406b:	41 5e                	pop    %r14
  40406d:	41 5f                	pop    %r15
  40406f:	c3                   	retq   
            copy_two_stacks(stack_idx, ds);
  404070:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  404075:	4c 89 e7             	mov    %r12,%rdi
  404078:	49 89 44 0c f8       	mov    %rax,-0x8(%r12,%rcx,1)
  40407d:	48 83 e9 01          	sub    $0x1,%rcx
  404081:	48 c1 e9 03          	shr    $0x3,%rcx
  404085:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  404088:	e9 4f fe ff ff       	jmpq   403edc <fc_solve_sfs_atomic_move_card_to_parent+0x14c>
  40408d:	0f 1f 00             	nopl   (%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  404090:	48 8b 54 24 40       	mov    0x40(%rsp),%rdx
  404095:	e9 f8 fe ff ff       	jmpq   403f92 <fc_solve_sfs_atomic_move_card_to_parent+0x202>
  40409a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  4040a0:	0f ab d6             	bts    %edx,%esi
  4040a3:	48 89 da             	mov    %rbx,%rdx
  4040a6:	41 89 72 14          	mov    %esi,0x14(%r10)
  4040aa:	48 8b 34 c7          	mov    (%rdi,%rax,8),%rsi
  4040ae:	48 c1 e2 07          	shl    $0x7,%rdx
  4040b2:	48 03 54 24 38       	add    0x38(%rsp),%rdx
  4040b7:	0f be 0e             	movsbl (%rsi),%ecx
  4040ba:	83 c1 01             	add    $0x1,%ecx
  4040bd:	48 63 c9             	movslq %ecx,%rcx
  4040c0:	48 83 f9 08          	cmp    $0x8,%rcx
  4040c4:	0f 83 86 00 00 00    	jae    404150 <fc_solve_sfs_atomic_move_card_to_parent+0x3c0>
  4040ca:	f6 c1 04             	test   $0x4,%cl
  4040cd:	0f 85 3f 01 00 00    	jne    404212 <fc_solve_sfs_atomic_move_card_to_parent+0x482>
  4040d3:	48 85 c9             	test   %rcx,%rcx
  4040d6:	74 14                	je     4040ec <fc_solve_sfs_atomic_move_card_to_parent+0x35c>
  4040d8:	0f b6 3e             	movzbl (%rsi),%edi
  4040db:	40 88 3a             	mov    %dil,(%rdx)
  4040de:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  4040e3:	f6 c1 02             	test   $0x2,%cl
  4040e6:	0f 85 3c 01 00 00    	jne    404228 <fc_solve_sfs_atomic_move_card_to_parent+0x498>
  4040ec:	48 8b 74 24 08       	mov    0x8(%rsp),%rsi
  4040f1:	48 89 14 c7          	mov    %rdx,(%rdi,%rax,8)
  4040f5:	48 8b 0c f7          	mov    (%rdi,%rsi,8),%rcx
  4040f9:	e9 04 fe ff ff       	jmpq   403f02 <fc_solve_sfs_atomic_move_card_to_parent+0x172>
  4040fe:	66 90                	xchg   %ax,%ax
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  404100:	48 83 c6 10          	add    $0x10,%rsi
  404104:	4c 89 44 24 20       	mov    %r8,0x20(%rsp)
  404109:	48 c1 e6 04          	shl    $0x4,%rsi
  40410d:	48 89 54 24 18       	mov    %rdx,0x18(%rsp)
  404112:	e8 59 d0 ff ff       	callq  401170 <realloc@plt>
        list->states =
  404117:	4c 8b 44 24 20       	mov    0x20(%rsp),%r8
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  40411c:	48 89 c7             	mov    %rax,%rdi
  40411f:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
        list->states =
  404124:	49 89 40 08          	mov    %rax,0x8(%r8)
  404128:	49 8b 00             	mov    (%r8),%rax
  40412b:	e9 7f fe ff ff       	jmpq   403faf <fc_solve_sfs_atomic_move_card_to_parent+0x21f>
    allocator->ptr = allocator->rollback_ptr;
  404130:	48 8b 81 f0 00 00 00 	mov    0xf0(%rcx),%rax
  404137:	48 89 81 e8 00 00 00 	mov    %rax,0xe8(%rcx)
  40413e:	e9 4a fe ff ff       	jmpq   403f8d <fc_solve_sfs_atomic_move_card_to_parent+0x1fd>
  404143:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40414a:	00 00 00 00 
  40414e:	66 90                	xchg   %ax,%ax
  404150:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  404155:	48 89 7c 0a f8       	mov    %rdi,-0x8(%rdx,%rcx,1)
  40415a:	48 83 e9 01          	sub    $0x1,%rcx
  40415e:	48 89 d7             	mov    %rdx,%rdi
  404161:	48 c1 e9 03          	shr    $0x3,%rcx
  404165:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  404168:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  40416d:	e9 7a ff ff ff       	jmpq   4040ec <fc_solve_sfs_atomic_move_card_to_parent+0x35c>
  404172:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404179:	00 00 00 00 
  40417d:	0f 1f 00             	nopl   (%rax)
    char *const new_data = meta_request_new_buffer(allocator->meta);
  404180:	49 8b 8e f8 00 00 00 	mov    0xf8(%r14),%rcx
    char *const ret = meta_alloc->recycle_bin;
  404187:	48 8b 01             	mov    (%rcx),%rax
    if (ret)
  40418a:	48 85 c0             	test   %rax,%rax
  40418d:	74 55                	je     4041e4 <fc_solve_sfs_atomic_move_card_to_parent+0x454>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40418f:	48 8b 30             	mov    (%rax),%rsi
  404192:	48 89 31             	mov    %rsi,(%rcx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  404195:	49 8b 8e d8 00 00 00 	mov    0xd8(%r14),%rcx
  40419c:	48 89 08             	mov    %rcx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40419f:	48 8d 48 08          	lea    0x8(%rax),%rcx
    allocator->old_list = new_data;
  4041a3:	49 89 86 d8 00 00 00 	mov    %rax,0xd8(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4041aa:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4041b0:	49 89 8e f0 00 00 00 	mov    %rcx,0xf0(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4041b7:	49 89 86 e0 00 00 00 	mov    %rax,0xe0(%r14)
  4041be:	e9 7b fe ff ff       	jmpq   40403e <fc_solve_sfs_atomic_move_card_to_parent+0x2ae>
  4041c3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4041ca:	00 00 00 00 
  4041ce:	66 90                	xchg   %ax,%ax
  4041d0:	8b 06                	mov    (%rsi),%eax
  4041d2:	41 89 04 24          	mov    %eax,(%r12)
  4041d6:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  4041da:	41 89 44 0c fc       	mov    %eax,-0x4(%r12,%rcx,1)
  4041df:	e9 f8 fc ff ff       	jmpq   403edc <fc_solve_sfs_atomic_move_card_to_parent+0x14c>
        return malloc(ALLOCED_SIZE);
  4041e4:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  4041e9:	4c 89 44 24 20       	mov    %r8,0x20(%rsp)
  4041ee:	89 5c 24 18          	mov    %ebx,0x18(%rsp)
  4041f2:	e8 f9 ce ff ff       	callq  4010f0 <malloc@plt>
  4041f7:	4c 8b 44 24 20       	mov    0x20(%rsp),%r8
  4041fc:	8b 54 24 18          	mov    0x18(%rsp),%edx
  404200:	eb 93                	jmp    404195 <fc_solve_sfs_atomic_move_card_to_parent+0x405>
  404202:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  404207:	66 41 89 44 0c fe    	mov    %ax,-0x2(%r12,%rcx,1)
  40420d:	e9 ca fc ff ff       	jmpq   403edc <fc_solve_sfs_atomic_move_card_to_parent+0x14c>
  404212:	8b 3e                	mov    (%rsi),%edi
  404214:	89 3a                	mov    %edi,(%rdx)
  404216:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  40421a:	89 74 0a fc          	mov    %esi,-0x4(%rdx,%rcx,1)
  40421e:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  404223:	e9 c4 fe ff ff       	jmpq   4040ec <fc_solve_sfs_atomic_move_card_to_parent+0x35c>
  404228:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  40422d:	66 89 74 0a fe       	mov    %si,-0x2(%rdx,%rcx,1)
  404232:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  404237:	e9 b0 fe ff ff       	jmpq   4040ec <fc_solve_sfs_atomic_move_card_to_parent+0x35c>
  40423c:	0f 1f 40 00          	nopl   0x0(%rax)

0000000000404240 <fc_solve_sfs_atomic_move_card_to_empty_stack>:
    if (soft_thread->num_vacant_stacks == 0)
  404240:	80 bf e3 01 00 00 00 	cmpb   $0x0,0x1e3(%rdi)
  404247:	0f 84 53 03 00 00    	je     4045a0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x360>
{
  40424d:	41 57                	push   %r15
  40424f:	41 56                	push   %r14
  404251:	41 55                	push   %r13
  404253:	41 54                	push   %r12
  404255:	55                   	push   %rbp
  404256:	48 89 cd             	mov    %rcx,%rbp
  404259:	53                   	push   %rbx
  40425a:	48 83 ec 58          	sub    $0x58,%rsp
    SET_empty_stack_idx(empty_stack_idx);
  40425e:	48 8b 06             	mov    (%rsi),%rax
  404261:	80 38 00             	cmpb   $0x0,(%rax)
  404264:	0f 84 90 03 00 00    	je     4045fa <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3ba>
  40426a:	48 8b 46 08          	mov    0x8(%rsi),%rax
  40426e:	80 38 00             	cmpb   $0x0,(%rax)
  404271:	0f 84 87 03 00 00    	je     4045fe <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3be>
  404277:	48 8b 46 10          	mov    0x10(%rsi),%rax
  40427b:	80 38 00             	cmpb   $0x0,(%rax)
  40427e:	0f 84 81 03 00 00    	je     404605 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3c5>
  404284:	48 8b 46 18          	mov    0x18(%rsi),%rax
  404288:	80 38 00             	cmpb   $0x0,(%rax)
  40428b:	0f 84 7b 03 00 00    	je     40460c <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3cc>
  404291:	48 8b 46 20          	mov    0x20(%rsi),%rax
  404295:	80 38 00             	cmpb   $0x0,(%rax)
  404298:	0f 84 39 03 00 00    	je     4045d7 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x397>
  40429e:	48 8b 46 28          	mov    0x28(%rsi),%rax
  4042a2:	80 38 00             	cmpb   $0x0,(%rax)
  4042a5:	0f 84 68 03 00 00    	je     404613 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3d3>
  4042ab:	48 8b 46 30          	mov    0x30(%rsi),%rax
  4042af:	80 38 00             	cmpb   $0x0,(%rax)
  4042b2:	0f 84 62 03 00 00    	je     40461a <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3da>
  4042b8:	4c 8b 46 38          	mov    0x38(%rsi),%r8
  4042bc:	b8 00 04 00 00       	mov    $0x400,%eax
  4042c1:	b9 08 00 00 00       	mov    $0x8,%ecx
  4042c6:	c7 44 24 04 00 01 00 	movl   $0x100,0x4(%rsp)
  4042cd:	00 
  4042ce:	41 80 38 00          	cmpb   $0x0,(%r8)
  4042d2:	0f 84 49 03 00 00    	je     404621 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3e1>
  4042d8:	48 89 f3             	mov    %rsi,%rbx
    tests_define_accessors();
  4042db:	48 8b 37             	mov    (%rdi),%rsi
  4042de:	48 89 7c 24 10       	mov    %rdi,0x10(%rsp)
        copy_two_stacks(stack_idx, empty_stack_idx);
  4042e3:	45 31 ff             	xor    %r15d,%r15d
  4042e6:	48 89 54 24 18       	mov    %rdx,0x18(%rsp)
  4042eb:	4c 63 e1             	movslq %ecx,%r12
    tests_define_accessors();
  4042ee:	48 8d be 00 01 00 00 	lea    0x100(%rsi),%rdi
  4042f5:	48 89 74 24 08       	mov    %rsi,0x8(%rsp)
        copy_two_stacks(stack_idx, empty_stack_idx);
  4042fa:	48 01 f8             	add    %rdi,%rax
    tests_define_accessors();
  4042fd:	48 89 7c 24 28       	mov    %rdi,0x28(%rsp)
        copy_two_stacks(stack_idx, empty_stack_idx);
  404302:	48 89 44 24 20       	mov    %rax,0x20(%rsp)
  404307:	eb 7b                	jmp    404384 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x144>
  404309:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        if (HT_FIELD(hard_thread, allocated_from_list))
  404310:	41 80 bd 18 05 00 00 	cmpb   $0x0,0x518(%r13)
  404317:	00 
  404318:	0f 84 02 02 00 00    	je     404520 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x2e0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  40431e:	49 8b 95 b0 00 00 00 	mov    0xb0(%r13),%rdx
  404325:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  40432a:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  40432d:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  404332:	49 89 85 b0 00 00 00 	mov    %rax,0xb0(%r13)
        return FCS_STATE_kv_to_collectible(&existing_state);
  404339:	4c 8b 6c 24 40       	mov    0x40(%rsp),%r13
    if ((!((list->num_states + (list->states != NULL)) &
  40433e:	48 8b 45 08          	mov    0x8(%rbp),%rax
  404342:	31 f6                	xor    %esi,%esi
  404344:	48 8b 7d 00          	mov    0x0(%rbp),%rdi
  404348:	48 85 c0             	test   %rax,%rax
  40434b:	40 0f 95 c6          	setne  %sil
  40434f:	48 01 fe             	add    %rdi,%rsi
  404352:	40 f6 c6 0f          	test   $0xf,%sil
  404356:	0f 84 d4 00 00 00    	je     404430 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x1f0>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  40435c:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
  404360:	48 c1 e7 04          	shl    $0x4,%rdi
  404364:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  404368:	48 01 f8             	add    %rdi,%rax
  40436b:	48 89 4d 00          	mov    %rcx,0x0(%rbp)
  40436f:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  404373:	4c 89 28             	mov    %r13,(%rax)
  404376:	49 83 c7 01          	add    $0x1,%r15
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  40437a:	49 83 ff 08          	cmp    $0x8,%r15
  40437e:	0f 84 bc 01 00 00    	je     404540 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x300>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  404384:	4a 8b 14 fb          	mov    (%rbx,%r15,8),%rdx
        const int cards_num = fcs_col_len(col);
  404388:	0f be 02             	movsbl (%rdx),%eax
        if (cards_num <= 1)
  40438b:	83 f8 01             	cmp    $0x1,%eax
  40438e:	7e e6                	jle    404376 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x136>
        sfs_check_state_begin();
  404390:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
  404395:	48 8d 74 24 30       	lea    0x30(%rsp),%rsi
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  40439a:	83 e8 01             	sub    $0x1,%eax
        sfs_check_state_begin();
  40439d:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  4043a2:	48 98                	cltq   
  4043a4:	44 0f b6 6c 02 01    	movzbl 0x1(%rdx,%rax,1),%r13d
        sfs_check_state_begin();
  4043aa:	48 89 da             	mov    %rbx,%rdx
  4043ad:	e8 6e d6 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
        copy_two_stacks(stack_idx, empty_stack_idx);
  4043b2:	48 8b 4c 24 38       	mov    0x38(%rsp),%rcx
  4043b7:	8b 41 14             	mov    0x14(%rcx),%eax
  4043ba:	44 0f a3 f8          	bt     %r15d,%eax
  4043be:	0f 83 ec 00 00 00    	jae    4044b0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x270>
  4043c4:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  4043c9:	4d 63 cf             	movslq %r15d,%r9
  4043cc:	85 44 24 04          	test   %eax,0x4(%rsp)
  4043d0:	74 7e                	je     404450 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x210>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  4043d2:	4a 8b 14 ca          	mov    (%rdx,%r9,8),%rdx
    if (!fc_solve_check_and_add_state(
  4043d6:	48 8d 74 24 30       	lea    0x30(%rsp),%rsi
    fcs_col_pop_top(col);
  4043db:	0f b6 02             	movzbl (%rdx),%eax
  4043de:	83 e8 01             	sub    $0x1,%eax
  4043e1:	88 02                	mov    %al,(%rdx)
  4043e3:	48 0f be c0          	movsbq %al,%rax
  4043e7:	c6 44 02 01 00       	movb   $0x0,0x1(%rdx,%rax,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  4043ec:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  4043f1:	4a 8b 14 e0          	mov    (%rax,%r12,8),%rdx
    fcs_col_push_card(col, card);
  4043f5:	48 0f be 02          	movsbq (%rdx),%rax
  4043f9:	8d 48 01             	lea    0x1(%rax),%ecx
  4043fc:	88 0a                	mov    %cl,(%rdx)
  4043fe:	44 88 6c 02 01       	mov    %r13b,0x1(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  404403:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  404408:	48 8d 54 24 40       	lea    0x40(%rsp),%rdx
    const_SLOT(hard_thread, soft_thread);
  40440d:	4c 8b 28             	mov    (%rax),%r13
    if (!fc_solve_check_and_add_state(
  404410:	4c 89 ef             	mov    %r13,%rdi
  404413:	e8 58 d7 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  404418:	84 c0                	test   %al,%al
  40441a:	0f 84 f0 fe ff ff    	je     404310 <fc_solve_sfs_atomic_move_card_to_empty_stack+0xd0>
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  404420:	4c 8b 6c 24 30       	mov    0x30(%rsp),%r13
  404425:	e9 14 ff ff ff       	jmpq   40433e <fc_solve_sfs_atomic_move_card_to_empty_stack+0xfe>
  40442a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  404430:	48 83 c6 10          	add    $0x10,%rsi
  404434:	48 89 c7             	mov    %rax,%rdi
  404437:	48 c1 e6 04          	shl    $0x4,%rsi
  40443b:	e8 30 cd ff ff       	callq  401170 <realloc@plt>
  404440:	48 8b 7d 00          	mov    0x0(%rbp),%rdi
        list->states =
  404444:	48 89 45 08          	mov    %rax,0x8(%rbp)
  404448:	e9 0f ff ff ff       	jmpq   40435c <fc_solve_sfs_atomic_move_card_to_empty_stack+0x11c>
  40444d:	0f 1f 00             	nopl   (%rax)
  404450:	0b 44 24 04          	or     0x4(%rsp),%eax
  404454:	4a 8b 34 e2          	mov    (%rdx,%r12,8),%rsi
  404458:	89 41 14             	mov    %eax,0x14(%rcx)
  40445b:	0f be 0e             	movsbl (%rsi),%ecx
  40445e:	83 c1 01             	add    $0x1,%ecx
  404461:	48 63 c9             	movslq %ecx,%rcx
  404464:	48 83 f9 08          	cmp    $0x8,%rcx
  404468:	0f 83 02 01 00 00    	jae    404570 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x330>
  40446e:	f6 c1 04             	test   $0x4,%cl
  404471:	0f 85 45 01 00 00    	jne    4045bc <fc_solve_sfs_atomic_move_card_to_empty_stack+0x37c>
  404477:	48 85 c9             	test   %rcx,%rcx
  40447a:	74 18                	je     404494 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x254>
  40447c:	0f b6 06             	movzbl (%rsi),%eax
  40447f:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  404484:	88 07                	mov    %al,(%rdi)
  404486:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  40448b:	f6 c1 02             	test   $0x2,%cl
  40448e:	0f 85 ad 01 00 00    	jne    404641 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x401>
  404494:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  404499:	4a 89 04 e2          	mov    %rax,(%rdx,%r12,8)
  40449d:	e9 30 ff ff ff       	jmpq   4043d2 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x192>
  4044a2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4044a9:	00 00 00 00 
  4044ad:	0f 1f 00             	nopl   (%rax)
  4044b0:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  4044b5:	4d 63 cf             	movslq %r15d,%r9
  4044b8:	44 0f ab f8          	bts    %r15d,%eax
  4044bc:	89 41 14             	mov    %eax,0x14(%rcx)
  4044bf:	4c 89 f8             	mov    %r15,%rax
  4044c2:	48 c1 e0 07          	shl    $0x7,%rax
  4044c6:	48 03 44 24 28       	add    0x28(%rsp),%rax
  4044cb:	4a 8b 34 ca          	mov    (%rdx,%r9,8),%rsi
  4044cf:	0f be 3e             	movsbl (%rsi),%edi
  4044d2:	83 c7 01             	add    $0x1,%edi
  4044d5:	48 63 ff             	movslq %edi,%rdi
  4044d8:	48 83 ff 08          	cmp    $0x8,%rdi
  4044dc:	73 72                	jae    404550 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x310>
  4044de:	40 f6 c7 04          	test   $0x4,%dil
  4044e2:	0f 85 b9 00 00 00    	jne    4045a1 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x361>
  4044e8:	48 85 ff             	test   %rdi,%rdi
  4044eb:	74 19                	je     404506 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x2c6>
  4044ed:	0f b6 16             	movzbl (%rsi),%edx
  4044f0:	88 10                	mov    %dl,(%rax)
  4044f2:	40 f6 c7 02          	test   $0x2,%dil
  4044f6:	0f 85 2c 01 00 00    	jne    404628 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3e8>
  4044fc:	48 8b 4c 24 38       	mov    0x38(%rsp),%rcx
  404501:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  404506:	4a 89 04 ca          	mov    %rax,(%rdx,%r9,8)
  40450a:	8b 41 14             	mov    0x14(%rcx),%eax
  40450d:	e9 ba fe ff ff       	jmpq   4043cc <fc_solve_sfs_atomic_move_card_to_empty_stack+0x18c>
  404512:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404519:	00 00 00 00 
  40451d:	0f 1f 00             	nopl   (%rax)
  404520:	49 8b 85 f0 00 00 00 	mov    0xf0(%r13),%rax
  404527:	49 89 85 e8 00 00 00 	mov    %rax,0xe8(%r13)
  40452e:	e9 06 fe ff ff       	jmpq   404339 <fc_solve_sfs_atomic_move_card_to_empty_stack+0xf9>
  404533:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40453a:	00 00 00 00 
  40453e:	66 90                	xchg   %ax,%ax
}
  404540:	48 83 c4 58          	add    $0x58,%rsp
  404544:	5b                   	pop    %rbx
  404545:	5d                   	pop    %rbp
  404546:	41 5c                	pop    %r12
  404548:	41 5d                	pop    %r13
  40454a:	41 5e                	pop    %r14
  40454c:	41 5f                	pop    %r15
  40454e:	c3                   	retq   
  40454f:	90                   	nop
        copy_two_stacks(stack_idx, empty_stack_idx);
  404550:	48 8b 54 3e f8       	mov    -0x8(%rsi,%rdi,1),%rdx
  404555:	48 8d 4f ff          	lea    -0x1(%rdi),%rcx
  404559:	48 c1 e9 03          	shr    $0x3,%rcx
  40455d:	48 89 54 38 f8       	mov    %rdx,-0x8(%rax,%rdi,1)
  404562:	48 89 c7             	mov    %rax,%rdi
  404565:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  404568:	eb 92                	jmp    4044fc <fc_solve_sfs_atomic_move_card_to_empty_stack+0x2bc>
  40456a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  404570:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  404575:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  40457a:	48 89 44 0f f8       	mov    %rax,-0x8(%rdi,%rcx,1)
  40457f:	48 83 e9 01          	sub    $0x1,%rcx
  404583:	48 c1 e9 03          	shr    $0x3,%rcx
  404587:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40458a:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  40458f:	e9 00 ff ff ff       	jmpq   404494 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x254>
  404594:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40459b:	00 00 00 00 
  40459f:	90                   	nop
  4045a0:	c3                   	retq   
  4045a1:	8b 16                	mov    (%rsi),%edx
  4045a3:	89 10                	mov    %edx,(%rax)
  4045a5:	8b 54 3e fc          	mov    -0x4(%rsi,%rdi,1),%edx
  4045a9:	89 54 38 fc          	mov    %edx,-0x4(%rax,%rdi,1)
  4045ad:	48 8b 4c 24 38       	mov    0x38(%rsp),%rcx
  4045b2:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  4045b7:	e9 4a ff ff ff       	jmpq   404506 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x2c6>
  4045bc:	8b 06                	mov    (%rsi),%eax
  4045be:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  4045c3:	89 07                	mov    %eax,(%rdi)
  4045c5:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  4045c9:	89 44 0f fc          	mov    %eax,-0x4(%rdi,%rcx,1)
  4045cd:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  4045d2:	e9 bd fe ff ff       	jmpq   404494 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x254>
    SET_empty_stack_idx(empty_stack_idx);
  4045d7:	b9 04 00 00 00       	mov    $0x4,%ecx
  4045dc:	0f 1f 40 00          	nopl   0x0(%rax)
  4045e0:	89 c8                	mov    %ecx,%eax
  4045e2:	41 be 01 00 00 00    	mov    $0x1,%r14d
  4045e8:	c1 e0 07             	shl    $0x7,%eax
  4045eb:	41 d3 e6             	shl    %cl,%r14d
  4045ee:	48 98                	cltq   
  4045f0:	44 89 74 24 04       	mov    %r14d,0x4(%rsp)
  4045f5:	e9 de fc ff ff       	jmpq   4042d8 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x98>
  4045fa:	31 c9                	xor    %ecx,%ecx
  4045fc:	eb e2                	jmp    4045e0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3a0>
  4045fe:	b9 01 00 00 00       	mov    $0x1,%ecx
  404603:	eb db                	jmp    4045e0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3a0>
  404605:	b9 02 00 00 00       	mov    $0x2,%ecx
  40460a:	eb d4                	jmp    4045e0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3a0>
  40460c:	b9 03 00 00 00       	mov    $0x3,%ecx
  404611:	eb cd                	jmp    4045e0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3a0>
  404613:	b9 05 00 00 00       	mov    $0x5,%ecx
  404618:	eb c6                	jmp    4045e0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3a0>
  40461a:	b9 06 00 00 00       	mov    $0x6,%ecx
  40461f:	eb bf                	jmp    4045e0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3a0>
  404621:	b9 07 00 00 00       	mov    $0x7,%ecx
  404626:	eb b8                	jmp    4045e0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3a0>
        copy_two_stacks(stack_idx, empty_stack_idx);
  404628:	0f b7 54 3e fe       	movzwl -0x2(%rsi,%rdi,1),%edx
  40462d:	66 89 54 38 fe       	mov    %dx,-0x2(%rax,%rdi,1)
  404632:	48 8b 4c 24 38       	mov    0x38(%rsp),%rcx
  404637:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  40463c:	e9 c5 fe ff ff       	jmpq   404506 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x2c6>
  404641:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  404646:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  40464b:	66 89 44 0e fe       	mov    %ax,-0x2(%rsi,%rcx,1)
  404650:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  404655:	e9 3a fe ff ff       	jmpq   404494 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x254>
  40465a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

0000000000404660 <fc_solve_sfs_empty_stack_into_freecells>:
{
  404660:	41 57                	push   %r15
  404662:	41 56                	push   %r14
  404664:	41 55                	push   %r13
  404666:	41 54                	push   %r12
  404668:	55                   	push   %rbp
  404669:	53                   	push   %rbx
  40466a:	48 83 ec 48          	sub    $0x48,%rsp
    const fcs_game_limit num_vacant_freecells =
  40466e:	0f b6 9f e4 01 00 00 	movzbl 0x1e4(%rdi),%ebx
    if ((!num_vacant_freecells) || soft_thread->num_vacant_stacks)
  404675:	84 db                	test   %bl,%bl
  404677:	0f 84 83 01 00 00    	je     404800 <fc_solve_sfs_empty_stack_into_freecells+0x1a0>
  40467d:	80 bf e3 01 00 00 00 	cmpb   $0x0,0x1e3(%rdi)
  404684:	0f 85 76 01 00 00    	jne    404800 <fc_solve_sfs_empty_stack_into_freecells+0x1a0>
    tests_define_accessors();
  40468a:	48 8b 07             	mov    (%rdi),%rax
  40468d:	49 89 cc             	mov    %rcx,%r12
  404690:	48 89 54 24 18       	mov    %rdx,0x18(%rsp)
  404695:	49 89 f5             	mov    %rsi,%r13
  404698:	48 89 fd             	mov    %rdi,%rbp
  40469b:	45 31 ff             	xor    %r15d,%r15d
  40469e:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  4046a3:	eb 19                	jmp    4046be <fc_solve_sfs_empty_stack_into_freecells+0x5e>
  4046a5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4046ac:	00 00 00 00 
  4046b0:	49 83 c7 01          	add    $0x1,%r15
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  4046b4:	49 83 ff 08          	cmp    $0x8,%r15
  4046b8:	0f 84 42 01 00 00    	je     404800 <fc_solve_sfs_empty_stack_into_freecells+0x1a0>
        const int cards_num = fcs_col_len(col);
  4046be:	4b 8b 44 fd 00       	mov    0x0(%r13,%r15,8),%rax
  4046c3:	44 0f be 30          	movsbl (%rax),%r14d
        if ((!cards_num) || (cards_num > num_vacant_freecells))
  4046c7:	45 85 f6             	test   %r14d,%r14d
  4046ca:	74 e4                	je     4046b0 <fc_solve_sfs_empty_stack_into_freecells+0x50>
  4046cc:	44 39 f3             	cmp    %r14d,%ebx
  4046cf:	7c df                	jl     4046b0 <fc_solve_sfs_empty_stack_into_freecells+0x50>
        sfs_check_state_begin();
  4046d1:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
  4046d6:	4c 89 ea             	mov    %r13,%rdx
  4046d9:	44 89 7c 24 10       	mov    %r15d,0x10(%rsp)
  4046de:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
  4046e3:	48 8d 74 24 20       	lea    0x20(%rsp),%rsi
  4046e8:	e8 33 d3 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
        my_copy_stack(stack_idx);
  4046ed:	48 8b 54 24 28       	mov    0x28(%rsp),%rdx
  4046f2:	4c 63 54 24 10       	movslq 0x10(%rsp),%r10
  4046f7:	8b 42 14             	mov    0x14(%rdx),%eax
  4046fa:	44 0f a3 d0          	bt     %r10d,%eax
  4046fe:	0f 83 61 01 00 00    	jae    404865 <fc_solve_sfs_empty_stack_into_freecells+0x205>
  404704:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  404709:	4e 8b 14 d1          	mov    (%rcx,%r10,8),%r10
        for (int c = 0; c < cards_num; ++c, ++b)
  40470d:	31 f6                	xor    %esi,%esi
        int b = 0;
  40470f:	31 c0                	xor    %eax,%eax
        for (int c = 0; c < cards_num; ++c, ++b)
  404711:	45 85 f6             	test   %r14d,%r14d
  404714:	0f 8e a0 00 00 00    	jle    4047ba <fc_solve_sfs_empty_stack_into_freecells+0x15a>
  40471a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                if (fcs_freecell_is_empty(new_state_key, b))
  404720:	48 63 d0             	movslq %eax,%rdx
            for (; b < LOCAL_FREECELLS_NUM; ++b)
  404723:	83 f8 03             	cmp    $0x3,%eax
  404726:	7f 57                	jg     40477f <fc_solve_sfs_empty_stack_into_freecells+0x11f>
                if (fcs_freecell_is_empty(new_state_key, b))
  404728:	80 7c 11 40 00       	cmpb   $0x0,0x40(%rcx,%rdx,1)
  40472d:	74 50                	je     40477f <fc_solve_sfs_empty_stack_into_freecells+0x11f>
            for (; b < LOCAL_FREECELLS_NUM; ++b)
  40472f:	8d 78 01             	lea    0x1(%rax),%edi
  404732:	83 ff 04             	cmp    $0x4,%edi
  404735:	0f 84 d5 00 00 00    	je     404810 <fc_solve_sfs_empty_stack_into_freecells+0x1b0>
                if (fcs_freecell_is_empty(new_state_key, b))
  40473b:	48 63 d7             	movslq %edi,%rdx
  40473e:	80 7c 11 40 00       	cmpb   $0x0,0x40(%rcx,%rdx,1)
  404743:	0f 84 d6 00 00 00    	je     40481f <fc_solve_sfs_empty_stack_into_freecells+0x1bf>
            for (; b < LOCAL_FREECELLS_NUM; ++b)
  404749:	8d 78 02             	lea    0x2(%rax),%edi
  40474c:	83 ff 04             	cmp    $0x4,%edi
  40474f:	0f 84 bb 00 00 00    	je     404810 <fc_solve_sfs_empty_stack_into_freecells+0x1b0>
                if (fcs_freecell_is_empty(new_state_key, b))
  404755:	48 63 d7             	movslq %edi,%rdx
  404758:	80 7c 11 40 00       	cmpb   $0x0,0x40(%rcx,%rdx,1)
  40475d:	0f 84 bc 00 00 00    	je     40481f <fc_solve_sfs_empty_stack_into_freecells+0x1bf>
            for (; b < LOCAL_FREECELLS_NUM; ++b)
  404763:	85 c0                	test   %eax,%eax
  404765:	0f 85 a5 00 00 00    	jne    404810 <fc_solve_sfs_empty_stack_into_freecells+0x1b0>
  40476b:	80 79 43 01          	cmpb   $0x1,0x43(%rcx)
  40476f:	19 c0                	sbb    %eax,%eax
  404771:	83 c0 04             	add    $0x4,%eax
  404774:	80 79 43 01          	cmpb   $0x1,0x43(%rcx)
  404778:	48 19 d2             	sbb    %rdx,%rdx
  40477b:	48 83 c2 04          	add    $0x4,%rdx
            fcs_col_pop_card(new_src_col, top_card);
  40477f:	41 0f be 3a          	movsbl (%r10),%edi
        for (int c = 0; c < cards_num; ++c, ++b)
  404783:	83 c6 01             	add    $0x1,%esi
  404786:	83 c0 01             	add    $0x1,%eax
            fcs_col_pop_card(new_src_col, top_card);
  404789:	89 f9                	mov    %edi,%ecx
  40478b:	83 ef 01             	sub    $0x1,%edi
  40478e:	83 e9 01             	sub    $0x1,%ecx
  404791:	48 63 ff             	movslq %edi,%rdi
  404794:	41 0f b6 7c 3a 01    	movzbl 0x1(%r10,%rdi,1),%edi
  40479a:	41 88 0a             	mov    %cl,(%r10)
  40479d:	48 0f be c9          	movsbq %cl,%rcx
  4047a1:	41 c6 44 0a 01 00    	movb   $0x0,0x1(%r10,%rcx,1)
            fcs_put_card_in_freecell(new_state_key, b, top_card);
  4047a7:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  4047ac:	40 88 7c 11 40       	mov    %dil,0x40(%rcx,%rdx,1)
        for (int c = 0; c < cards_num; ++c, ++b)
  4047b1:	41 39 f6             	cmp    %esi,%r14d
  4047b4:	0f 85 66 ff ff ff    	jne    404720 <fc_solve_sfs_empty_stack_into_freecells+0xc0>
    const_SLOT(hard_thread, soft_thread);
  4047ba:	4c 8b 75 00          	mov    0x0(%rbp),%r14
    if (!fc_solve_check_and_add_state(
  4047be:	48 8d 54 24 30       	lea    0x30(%rsp),%rdx
  4047c3:	48 8d 74 24 20       	lea    0x20(%rsp),%rsi
  4047c8:	4c 89 f7             	mov    %r14,%rdi
  4047cb:	e8 a0 d3 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  4047d0:	84 c0                	test   %al,%al
  4047d2:	75 52                	jne    404826 <fc_solve_sfs_empty_stack_into_freecells+0x1c6>
        if (HT_FIELD(hard_thread, allocated_from_list))
  4047d4:	41 80 be 18 05 00 00 	cmpb   $0x0,0x518(%r14)
  4047db:	00 
  4047dc:	0f 85 06 01 00 00    	jne    4048e8 <fc_solve_sfs_empty_stack_into_freecells+0x288>
  4047e2:	49 8b 86 f0 00 00 00 	mov    0xf0(%r14),%rax
  4047e9:	49 89 86 e8 00 00 00 	mov    %rax,0xe8(%r14)
        return FCS_STATE_kv_to_collectible(&existing_state);
  4047f0:	48 8b 4c 24 30       	mov    0x30(%rsp),%rcx
    return (fcs_collectible_state *)(s->key);
  4047f5:	eb 34                	jmp    40482b <fc_solve_sfs_empty_stack_into_freecells+0x1cb>
  4047f7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4047fe:	00 00 
}
  404800:	48 83 c4 48          	add    $0x48,%rsp
  404804:	5b                   	pop    %rbx
  404805:	5d                   	pop    %rbp
  404806:	41 5c                	pop    %r12
  404808:	41 5d                	pop    %r13
  40480a:	41 5e                	pop    %r14
  40480c:	41 5f                	pop    %r15
  40480e:	c3                   	retq   
  40480f:	90                   	nop
            for (; b < LOCAL_FREECELLS_NUM; ++b)
  404810:	b8 04 00 00 00       	mov    $0x4,%eax
  404815:	ba 04 00 00 00       	mov    $0x4,%edx
  40481a:	e9 60 ff ff ff       	jmpq   40477f <fc_solve_sfs_empty_stack_into_freecells+0x11f>
                if (fcs_freecell_is_empty(new_state_key, b))
  40481f:	89 f8                	mov    %edi,%eax
  404821:	e9 59 ff ff ff       	jmpq   40477f <fc_solve_sfs_empty_stack_into_freecells+0x11f>
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  404826:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
    if ((!((list->num_states + (list->states != NULL)) &
  40482b:	49 8b 44 24 08       	mov    0x8(%r12),%rax
  404830:	31 f6                	xor    %esi,%esi
  404832:	49 8b 14 24          	mov    (%r12),%rdx
  404836:	48 85 c0             	test   %rax,%rax
  404839:	40 0f 95 c6          	setne  %sil
  40483d:	48 01 d6             	add    %rdx,%rsi
  404840:	40 f6 c6 0f          	test   $0xf,%sil
  404844:	74 7a                	je     4048c0 <fc_solve_sfs_empty_stack_into_freecells+0x260>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  404846:	48 8d 72 01          	lea    0x1(%rdx),%rsi
  40484a:	48 c1 e2 04          	shl    $0x4,%rdx
  40484e:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  404852:	48 01 d0             	add    %rdx,%rax
  404855:	49 89 34 24          	mov    %rsi,(%r12)
  404859:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  40485d:	48 89 08             	mov    %rcx,(%rax)
  404860:	e9 4b fe ff ff       	jmpq   4046b0 <fc_solve_sfs_empty_stack_into_freecells+0x50>
        my_copy_stack(stack_idx);
  404865:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  40486a:	44 0f ab d0          	bts    %r10d,%eax
  40486e:	89 42 14             	mov    %eax,0x14(%rdx)
  404871:	49 63 d2             	movslq %r10d,%rdx
  404874:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
  404879:	4c 89 f8             	mov    %r15,%rax
  40487c:	48 c1 e0 07          	shl    $0x7,%rax
  404880:	48 8b 34 d1          	mov    (%rcx,%rdx,8),%rsi
  404884:	4c 8d 94 07 00 01 00 	lea    0x100(%rdi,%rax,1),%r10
  40488b:	00 
  40488c:	0f be 06             	movsbl (%rsi),%eax
  40488f:	83 c0 01             	add    $0x1,%eax
  404892:	48 98                	cltq   
  404894:	48 83 f8 08          	cmp    $0x8,%rax
  404898:	72 6e                	jb     404908 <fc_solve_sfs_empty_stack_into_freecells+0x2a8>
  40489a:	48 8b 4c 06 f8       	mov    -0x8(%rsi,%rax,1),%rcx
  40489f:	4c 89 d7             	mov    %r10,%rdi
  4048a2:	49 89 4c 02 f8       	mov    %rcx,-0x8(%r10,%rax,1)
  4048a7:	48 8d 48 ff          	lea    -0x1(%rax),%rcx
  4048ab:	48 c1 e9 03          	shr    $0x3,%rcx
  4048af:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4048b2:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  4048b7:	4c 89 14 d1          	mov    %r10,(%rcx,%rdx,8)
  4048bb:	e9 4d fe ff ff       	jmpq   40470d <fc_solve_sfs_empty_stack_into_freecells+0xad>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  4048c0:	48 83 c6 10          	add    $0x10,%rsi
  4048c4:	48 89 c7             	mov    %rax,%rdi
  4048c7:	48 89 4c 24 10       	mov    %rcx,0x10(%rsp)
  4048cc:	48 c1 e6 04          	shl    $0x4,%rsi
  4048d0:	e8 9b c8 ff ff       	callq  401170 <realloc@plt>
  4048d5:	49 8b 14 24          	mov    (%r12),%rdx
        list->states =
  4048d9:	49 89 44 24 08       	mov    %rax,0x8(%r12)
  4048de:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
  4048e3:	e9 5e ff ff ff       	jmpq   404846 <fc_solve_sfs_empty_stack_into_freecells+0x1e6>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  4048e8:	49 8b 96 b0 00 00 00 	mov    0xb0(%r14),%rdx
  4048ef:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  4048f4:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  4048f7:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  4048fc:	49 89 86 b0 00 00 00 	mov    %rax,0xb0(%r14)
  404903:	e9 e8 fe ff ff       	jmpq   4047f0 <fc_solve_sfs_empty_stack_into_freecells+0x190>
  404908:	a8 04                	test   $0x4,%al
  40490a:	75 26                	jne    404932 <fc_solve_sfs_empty_stack_into_freecells+0x2d2>
  40490c:	48 85 c0             	test   %rax,%rax
  40490f:	74 a6                	je     4048b7 <fc_solve_sfs_empty_stack_into_freecells+0x257>
  404911:	0f b6 0e             	movzbl (%rsi),%ecx
  404914:	41 88 0a             	mov    %cl,(%r10)
  404917:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  40491c:	a8 02                	test   $0x2,%al
  40491e:	74 97                	je     4048b7 <fc_solve_sfs_empty_stack_into_freecells+0x257>
  404920:	0f b7 4c 06 fe       	movzwl -0x2(%rsi,%rax,1),%ecx
  404925:	66 41 89 4c 02 fe    	mov    %cx,-0x2(%r10,%rax,1)
  40492b:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  404930:	eb 85                	jmp    4048b7 <fc_solve_sfs_empty_stack_into_freecells+0x257>
  404932:	8b 0e                	mov    (%rsi),%ecx
  404934:	41 89 0a             	mov    %ecx,(%r10)
  404937:	8b 4c 06 fc          	mov    -0x4(%rsi,%rax,1),%ecx
  40493b:	41 89 4c 02 fc       	mov    %ecx,-0x4(%r10,%rax,1)
  404940:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  404945:	e9 6d ff ff ff       	jmpq   4048b7 <fc_solve_sfs_empty_stack_into_freecells+0x257>
  40494a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

0000000000404950 <fc_solve_sfs_move_cards_to_a_different_parent>:
{
  404950:	41 57                	push   %r15
  404952:	41 56                	push   %r14
  404954:	49 89 f6             	mov    %rsi,%r14
  404957:	41 55                	push   %r13
  404959:	41 54                	push   %r12
  40495b:	55                   	push   %rbp
  40495c:	53                   	push   %rbx
  40495d:	48 81 ec d8 00 00 00 	sub    $0xd8,%rsp
    MOVE_FUNCS__define_common();
  404964:	48 8b 1f             	mov    (%rdi),%rbx
}

static inline const int8_t *fc_solve_calc_positions_by_rank_location(
    fcs_soft_thread *const soft_thread)
{
    if (soft_thread->super_method_type == FCS_SUPER_METHOD_DFS)
  404967:	8b 47 20             	mov    0x20(%rdi),%eax
{
  40496a:	48 89 7c 24 38       	mov    %rdi,0x38(%rsp)
  40496f:	48 89 54 24 58       	mov    %rdx,0x58(%rsp)
  404974:	48 89 4c 24 30       	mov    %rcx,0x30(%rsp)
    MOVE_FUNCS__define_common();
  404979:	48 89 5c 24 50       	mov    %rbx,0x50(%rsp)
  40497e:	48 81 c3 00 01 00 00 	add    $0x100,%rbx
  404985:	48 89 9c 24 90 00 00 	mov    %rbx,0x90(%rsp)
  40498c:	00 
    const fcs_game_limit num_vacant_freecells =
  40498d:	0f b6 9f e4 01 00 00 	movzbl 0x1e4(%rdi),%ebx
  404994:	88 5c 24 1e          	mov    %bl,0x1e(%rsp)
    const fcs_game_limit num_vacant_stacks = soft_thread->num_vacant_stacks;
  404998:	0f b6 9f e3 01 00 00 	movzbl 0x1e3(%rdi),%ebx
  40499f:	88 5c 24 1f          	mov    %bl,0x1f(%rsp)
    const int derived_start_idx = derived_states_list->num_states;
  4049a3:	48 8b 19             	mov    (%rcx),%rbx
  4049a6:	48 89 9c 24 98 00 00 	mov    %rbx,0x98(%rsp)
  4049ad:	00 
        return (DFS_VAR(soft_thread, soft_dfs_info)[DFS_VAR(soft_thread, depth)]
                    .positions_by_rank);
    }
    else
    {
        return (BEFS_M_VAR(soft_thread, befs_positions_by_rank));
  4049ae:	48 8d 5f 60          	lea    0x60(%rdi),%rbx
  4049b2:	48 89 9c 24 80 00 00 	mov    %rbx,0x80(%rsp)
  4049b9:	00 
    if (soft_thread->super_method_type == FCS_SUPER_METHOD_DFS)
  4049ba:	85 c0                	test   %eax,%eax
  4049bc:	75 18                	jne    4049d6 <fc_solve_sfs_move_cards_to_a_different_parent+0x86>
        return (DFS_VAR(soft_thread, soft_dfs_info)[DFS_VAR(soft_thread, depth)]
  4049be:	48 69 47 38 b0 00 00 	imul   $0xb0,0x38(%rdi),%rax
  4049c5:	00 
  4049c6:	48 03 47 30          	add    0x30(%rdi),%rax
  4049ca:	48 83 c0 40          	add    $0x40,%rax
  4049ce:	48 89 84 24 80 00 00 	mov    %rax,0x80(%rsp)
  4049d5:	00 
{
  4049d6:	48 c7 04 24 00 00 00 	movq   $0x0,(%rsp)
  4049dd:	00 
    return -1;
  4049de:	4d 89 f5             	mov    %r14,%r13
  4049e1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4049e8:	00 00 00 00 
  4049ec:	0f 1f 40 00          	nopl   0x0(%rax)
  4049f0:	48 8b 04 24          	mov    (%rsp),%rax
  4049f4:	89 c6                	mov    %eax,%esi
  4049f6:	89 84 24 8c 00 00 00 	mov    %eax,0x8c(%rsp)
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  4049fd:	49 8b 44 c5 00       	mov    0x0(%r13,%rax,8),%rax
  404a02:	48 89 44 24 68       	mov    %rax,0x68(%rsp)
        const int cards_num = fcs_col_len(col);
  404a07:	0f be 00             	movsbl (%rax),%eax
  404a0a:	89 44 24 64          	mov    %eax,0x64(%rsp)
        if (cards_num < 2)
  404a0e:	83 f8 01             	cmp    $0x1,%eax
  404a11:	0f 8e 53 03 00 00    	jle    404d6a <fc_solve_sfs_move_cards_to_a_different_parent+0x41a>
        fcs_card upper_card = fcs_col_get_card(col, cards_num - 1);
  404a17:	4c 8b 4c 24 68       	mov    0x68(%rsp),%r9
  404a1c:	89 c3                	mov    %eax,%ebx
  404a1e:	8d 40 ff             	lea    -0x1(%rax),%eax
  404a21:	48 98                	cltq   
  404a23:	41 0f b6 54 01 01    	movzbl 0x1(%r9,%rax,1),%edx
        for (min_card_height = cards_num - 2; min_card_height >= 0;
  404a29:	8d 43 fe             	lea    -0x2(%rbx),%eax
  404a2c:	48 98                	cltq   
  404a2e:	48 0f be ca          	movsbq %dl,%rcx
  404a32:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404a39:	00 00 00 00 
  404a3d:	0f 1f 00             	nopl   (%rax)
            lower_card = fcs_col_get_card(col, min_card_height);
  404a40:	49 0f be 54 01 01    	movsbq 0x1(%r9,%rax,1),%rdx
  404a46:	41 89 c0             	mov    %eax,%r8d
  404a49:	48 89 d7             	mov    %rdx,%rdi
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  404a4c:	48 c1 e2 06          	shl    $0x6,%rdx
            if (!fcs_is_parent_card(upper_card, lower_card))
  404a50:	80 bc 11 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rcx,%rdx,1)
  404a57:	00 
  404a58:	0f 84 0f 08 00 00    	je     40526d <fc_solve_sfs_move_cards_to_a_different_parent+0x91d>
  404a5e:	48 83 e8 01          	sub    $0x1,%rax
             upper_card = lower_card, min_card_height--)
  404a62:	48 0f be cf          	movsbq %dil,%rcx
        for (min_card_height = cards_num - 2; min_card_height >= 0;
  404a66:	83 f8 ff             	cmp    $0xffffffff,%eax
  404a69:	75 d5                	jne    404a40 <fc_solve_sfs_move_cards_to_a_different_parent+0xf0>
        min_card_height += 2;
  404a6b:	41 b8 01 00 00 00    	mov    $0x1,%r8d
  404a71:	0f b6 8c 24 8c 00 00 	movzbl 0x8c(%rsp),%ecx
  404a78:	00 
  404a79:	b8 01 00 00 00       	mov    $0x1,%eax
                    ((((((stack_idx << 8) | c) << 8) | ds) << 8) | dc);
  404a7e:	c1 e6 08             	shl    $0x8,%esi
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  404a81:	4c 89 6c 24 78       	mov    %r13,0x78(%rsp)
  404a86:	44 8b 64 24 64       	mov    0x64(%rsp),%r12d
                    ((((((stack_idx << 8) | c) << 8) | ds) << 8) | dc);
  404a8b:	89 b4 24 88 00 00 00 	mov    %esi,0x88(%rsp)
  404a92:	d3 e0                	shl    %cl,%eax
  404a94:	89 44 24 4c          	mov    %eax,0x4c(%rsp)
  404a98:	48 8b 04 24          	mov    (%rsp),%rax
  404a9c:	45 29 c4             	sub    %r8d,%r12d
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  404a9f:	44 89 64 24 60       	mov    %r12d,0x60(%rsp)
  404aa4:	48 c1 e0 07          	shl    $0x7,%rax
  404aa8:	48 03 84 24 90 00 00 	add    0x90(%rsp),%rax
  404aaf:	00 
  404ab0:	48 89 44 24 70       	mov    %rax,0x70(%rsp)
  404ab5:	49 63 c0             	movslq %r8d,%rax
  404ab8:	48 89 44 24 28       	mov    %rax,0x28(%rsp)
  404abd:	0f 1f 00             	nopl   (%rax)
            FCS_POS_IDX_TO_CHECK_START_LOOP(card)
  404ac0:	48 8b 74 24 28       	mov    0x28(%rsp),%rsi
  404ac5:	48 8b 44 24 68       	mov    0x68(%rsp),%rax
  404aca:	48 8b bc 24 80 00 00 	mov    0x80(%rsp),%rdi
  404ad1:	00 
  404ad2:	48 0f be 44 30 01    	movsbq 0x1(%rax,%rsi,1),%rax
  404ad8:	48 c1 e0 04          	shl    $0x4,%rax
  404adc:	48 8b 98 40 02 41 00 	mov    0x410240(%rax),%rbx
  404ae3:	48 01 fb             	add    %rdi,%rbx
  404ae6:	48 03 b8 48 02 41 00 	add    0x410248(%rax),%rdi
                    ((((((stack_idx << 8) | c) << 8) | ds) << 8) | dc);
  404aed:	8b 84 24 88 00 00 00 	mov    0x88(%rsp),%eax
            FCS_POS_IDX_TO_CHECK_START_LOOP(card)
  404af4:	48 89 7c 24 08       	mov    %rdi,0x8(%rsp)
                    ((((((stack_idx << 8) | c) << 8) | ds) << 8) | dc);
  404af9:	09 f0                	or     %esi,%eax
  404afb:	c1 e0 08             	shl    $0x8,%eax
  404afe:	48 98                	cltq   
  404b00:	48 89 44 24 40       	mov    %rax,0x40(%rsp)
            FCS_POS_IDX_TO_CHECK_START_LOOP(card)
  404b05:	48 39 fb             	cmp    %rdi,%rbx
  404b08:	0f 83 3d 02 00 00    	jae    404d4b <fc_solve_sfs_move_cards_to_a_different_parent+0x3fb>
  404b0e:	8b 6c 24 60          	mov    0x60(%rsp),%ebp
  404b12:	4c 8b 64 24 78       	mov    0x78(%rsp),%r12
  404b17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  404b1e:	00 00 
                const int_fast32_t ds = pos_idx_to_check[0];
  404b20:	4c 0f be 2b          	movsbq (%rbx),%r13
                if ((ds == -1) || (ds == stack_idx))
  404b24:	49 83 fd ff          	cmp    $0xffffffffffffffff,%r13
  404b28:	0f 84 0e 02 00 00    	je     404d3c <fc_solve_sfs_move_cards_to_a_different_parent+0x3ec>
  404b2e:	4d 0f be f5          	movsbq %r13b,%r14
  404b32:	44 88 6c 24 10       	mov    %r13b,0x10(%rsp)
  404b37:	44 3b 34 24          	cmp    (%rsp),%r14d
  404b3b:	0f 84 fb 01 00 00    	je     404d3c <fc_solve_sfs_move_cards_to_a_different_parent+0x3ec>
                const int dest_cards_num = fcs_col_len(dest_col);
  404b41:	4b 8b 04 ec          	mov    (%r12,%r13,8),%rax
                int num_cards_to_relocate = dest_cards_num - dc - 1;
  404b45:	44 0f be 7b 01       	movsbl 0x1(%rbx),%r15d
                    min(num_cards_to_relocate, num_virtual_vacant_stacks);
  404b4a:	0f b6 4c 24 1f       	movzbl 0x1f(%rsp),%ecx
                int num_cards_to_relocate = dest_cards_num - dc - 1;
  404b4f:	0f be 10             	movsbl (%rax),%edx
                    min(num_cards_to_relocate, num_vacant_freecells);
  404b52:	0f b6 44 24 1e       	movzbl 0x1e(%rsp),%eax
                int num_cards_to_relocate = dest_cards_num - dc - 1;
  404b57:	45 89 f9             	mov    %r15d,%r9d
  404b5a:	41 f7 d1             	not    %r9d
  404b5d:	44 01 ca             	add    %r9d,%edx
                const int freecells_to_fill =
  404b60:	39 d0                	cmp    %edx,%eax
  404b62:	41 89 d3             	mov    %edx,%r11d
  404b65:	44 0f 4e d8          	cmovle %eax,%r11d
                num_cards_to_relocate -= freecells_to_fill;
  404b69:	44 29 da             	sub    %r11d,%edx
                if (!((num_cards_to_relocate == 0) &&
  404b6c:	39 d1                	cmp    %edx,%ecx
  404b6e:	0f 8c c8 01 00 00    	jl     404d3c <fc_solve_sfs_move_cards_to_a_different_parent+0x3ec>
                const int freestacks_to_fill =
  404b74:	0f 4e d1             	cmovle %ecx,%edx
                        (calc_max_sequence_move(
  404b77:	44 29 d8             	sub    %r11d,%eax
  404b7a:	44 89 5c 24 48       	mov    %r11d,0x48(%rsp)
  404b7f:	83 c0 01             	add    $0x1,%eax
  404b82:	29 d1                	sub    %edx,%ecx
  404b84:	89 54 24 20          	mov    %edx,0x20(%rsp)
  404b88:	d3 e0                	shl    %cl,%eax
                if (!((num_cards_to_relocate == 0) &&
  404b8a:	39 e8                	cmp    %ebp,%eax
  404b8c:	0f 8c aa 01 00 00    	jl     404d3c <fc_solve_sfs_move_cards_to_a_different_parent+0x3ec>
                sfs_check_state_begin();
  404b92:	48 8b 4c 24 58       	mov    0x58(%rsp),%rcx
  404b97:	4c 89 e2             	mov    %r12,%rdx
  404b9a:	48 8b 7c 24 50       	mov    0x50(%rsp),%rdi
  404b9f:	48 8d b4 24 b0 00 00 	lea    0xb0(%rsp),%rsi
  404ba6:	00 
  404ba7:	e8 74 ce ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
                copy_two_stacks(stack_idx, ds);
  404bac:	48 8b 94 24 b8 00 00 	mov    0xb8(%rsp),%rdx
  404bb3:	00 
  404bb4:	44 8b 4c 24 20       	mov    0x20(%rsp),%r9d
  404bb9:	44 8b 5c 24 48       	mov    0x48(%rsp),%r11d
  404bbe:	44 0f b6 54 24 10    	movzbl 0x10(%rsp),%r10d
  404bc4:	8b 42 14             	mov    0x14(%rdx),%eax
  404bc7:	85 44 24 4c          	test   %eax,0x4c(%rsp)
  404bcb:	0f 84 cf 02 00 00    	je     404ea0 <fc_solve_sfs_move_cards_to_a_different_parent+0x550>
  404bd1:	4c 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%r8
  404bd8:	00 
  404bd9:	44 0f a3 d0          	bt     %r10d,%eax
  404bdd:	0f 83 5d 02 00 00    	jae    404e40 <fc_solve_sfs_move_cards_to_a_different_parent+0x4f0>
                empty_two_cols_from_new_state(soft_thread,
  404be3:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  404be8:	43 8d 14 0b          	lea    (%r11,%r9,1),%edx
                const int cols_indexes[3] = {ds, -1, -1};
  404bec:	44 89 b4 24 a4 00 00 	mov    %r14d,0xa4(%rsp)
  404bf3:	00 
  404bf4:	48 c7 84 24 a8 00 00 	movq   $0xffffffffffffffff,0xa8(%rsp)
  404bfb:	00 ff ff ff ff 
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  404c00:	89 94 24 c0 00 00 00 	mov    %edx,0xc0(%rsp)
                empty_two_cols_from_new_state(soft_thread,
  404c07:	4c 8b 18             	mov    (%rax),%r11
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  404c0a:	48 b8 00 00 00 00 ff 	movabs $0xffffffff00000000,%rax
  404c11:	ff ff ff 
  404c14:	48 89 84 24 c4 00 00 	mov    %rax,0xc4(%rsp)
  404c1b:	00 
            while ((*col_num_cards) == 0)
  404c1c:	85 d2                	test   %edx,%edx
  404c1e:	0f 85 ec 02 00 00    	jne    404f10 <fc_solve_sfs_move_cards_to_a_different_parent+0x5c0>
  404c24:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404c2b:	00 00 00 00 
  404c2f:	90                   	nop
  404c30:	48 8b 8c 24 b0 00 00 	mov    0xb0(%rsp),%rcx
  404c37:	00 

static inline void fc_solve_move_sequence_function(
    fcs_state *const s FCS__pass_moves(fcs_move_stack *const moves),
    const size_t dest_col_i, const size_t src_col_i, const size_t cards_num)
{
    fcs_col_transfer_cards(fcs_state_get_col(*s, dest_col_i),
  404c38:	48 8b 04 24          	mov    (%rsp),%rax
    const size_t cards_size = (((size_t)cards_num) * sizeof(fcs_card));
  404c3c:	4c 63 f5             	movslq %ebp,%r14
  404c3f:	48 8b 14 c1          	mov    (%rcx,%rax,8),%rdx
  404c43:	4a 8b 0c e9          	mov    (%rcx,%r13,8),%rcx
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  404c47:	0f b6 02             	movzbl (%rdx),%eax
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  404c4a:	48 89 4c 24 20       	mov    %rcx,0x20(%rsp)
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  404c4f:	29 e8                	sub    %ebp,%eax
  404c51:	88 02                	mov    %al,(%rdx)
  404c53:	48 0f be c0          	movsbq %al,%rax
    fcs_card *const src_cards_ptr =
  404c57:	4c 8d 44 02 01       	lea    0x1(%rdx,%rax,1),%r8
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  404c5c:	48 0f be 01          	movsbq (%rcx),%rax
  404c60:	4c 89 f2             	mov    %r14,%rdx
  404c63:	4c 89 c6             	mov    %r8,%rsi
  404c66:	4c 89 44 24 10       	mov    %r8,0x10(%rsp)
  404c6b:	48 8d 7c 01 01       	lea    0x1(%rcx,%rax,1),%rdi
  404c70:	e8 6b c4 ff ff       	callq  4010e0 <memcpy@plt>
    fcs_col_len(dest_col) += cards_num;
  404c75:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
    memset(src_cards_ptr, 0, cards_size);
  404c7a:	31 f6                	xor    %esi,%esi
  404c7c:	4c 89 f2             	mov    %r14,%rdx
  404c7f:	4c 8b 44 24 10       	mov    0x10(%rsp),%r8
    fcs_col_len(dest_col) += cards_num;
  404c84:	40 00 29             	add    %bpl,(%rcx)
    memset(src_cards_ptr, 0, cards_size);
  404c87:	4c 89 c7             	mov    %r8,%rdi
  404c8a:	e8 11 c4 ff ff       	callq  4010a0 <memset@plt>
                    ((((((stack_idx << 8) | c) << 8) | ds) << 8) | dc);
  404c8f:	4c 0b 6c 24 40       	or     0x40(%rsp),%r13
    if (!fc_solve_check_and_add_state(
  404c94:	48 8d 94 24 c0 00 00 	lea    0xc0(%rsp),%rdx
  404c9b:	00 
    const_SLOT(hard_thread, soft_thread);
  404c9c:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  404ca1:	48 8d b4 24 b0 00 00 	lea    0xb0(%rsp),%rsi
  404ca8:	00 
  404ca9:	49 c1 e5 08          	shl    $0x8,%r13
                state_context_value =
  404cad:	45 09 ef             	or     %r13d,%r15d
    const_SLOT(hard_thread, soft_thread);
  404cb0:	4c 8b 28             	mov    (%rax),%r13
    if (!fc_solve_check_and_add_state(
  404cb3:	4c 89 ef             	mov    %r13,%rdi
  404cb6:	e8 b5 ce ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  404cbb:	84 c0                	test   %al,%al
  404cbd:	0f 85 3d 01 00 00    	jne    404e00 <fc_solve_sfs_move_cards_to_a_different_parent+0x4b0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  404cc3:	41 80 bd 18 05 00 00 	cmpb   $0x0,0x518(%r13)
  404cca:	00 
  404ccb:	0f 84 ef 04 00 00    	je     4051c0 <fc_solve_sfs_move_cards_to_a_different_parent+0x870>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  404cd1:	49 8b 95 b0 00 00 00 	mov    0xb0(%r13),%rdx
  404cd8:	48 8b 84 24 b8 00 00 	mov    0xb8(%rsp),%rax
  404cdf:	00 
  404ce0:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  404ce3:	48 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%rax
  404cea:	00 
  404ceb:	49 89 85 b0 00 00 00 	mov    %rax,0xb0(%r13)
        return FCS_STATE_kv_to_collectible(&existing_state);
  404cf2:	4c 8b ac 24 c0 00 00 	mov    0xc0(%rsp),%r13
  404cf9:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  404cfa:	48 8b 74 24 30       	mov    0x30(%rsp),%rsi
  404cff:	31 d2                	xor    %edx,%edx
  404d01:	48 8b 7e 08          	mov    0x8(%rsi),%rdi
  404d05:	48 8b 06             	mov    (%rsi),%rax
  404d08:	48 85 ff             	test   %rdi,%rdi
  404d0b:	0f 95 c2             	setne  %dl
  404d0e:	48 01 c2             	add    %rax,%rdx
  404d11:	f6 c2 0f             	test   $0xf,%dl
  404d14:	0f 84 f6 00 00 00    	je     404e10 <fc_solve_sfs_move_cards_to_a_different_parent+0x4c0>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  404d1a:	48 8b 74 24 30       	mov    0x30(%rsp),%rsi
  404d1f:	48 8d 50 01          	lea    0x1(%rax),%rdx
  404d23:	48 c1 e0 04          	shl    $0x4,%rax
  404d27:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  404d2b:	48 01 f8             	add    %rdi,%rax
  404d2e:	48 89 16             	mov    %rdx,(%rsi)
  404d31:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  404d35:	4c 89 28             	mov    %r13,(%rax)
  404d38:	44 89 78 08          	mov    %r15d,0x8(%rax)
            FCS_POS_IDX_TO_CHECK_START_LOOP(card)
  404d3c:	48 83 c3 04          	add    $0x4,%rbx
  404d40:	48 39 5c 24 08       	cmp    %rbx,0x8(%rsp)
  404d45:	0f 87 d5 fd ff ff    	ja     404b20 <fc_solve_sfs_move_cards_to_a_different_parent+0x1d0>
  404d4b:	48 83 44 24 28 01    	addq   $0x1,0x28(%rsp)
  404d51:	83 6c 24 60 01       	subl   $0x1,0x60(%rsp)
  404d56:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
        for (int c = min_card_height; c < cards_num; c++)
  404d5b:	39 44 24 64          	cmp    %eax,0x64(%rsp)
  404d5f:	0f 8f 5b fd ff ff    	jg     404ac0 <fc_solve_sfs_move_cards_to_a_different_parent+0x170>
  404d65:	4c 8b 6c 24 78       	mov    0x78(%rsp),%r13
  404d6a:	48 83 04 24 01       	addq   $0x1,(%rsp)
  404d6f:	48 8b 04 24          	mov    (%rsp),%rax
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  404d73:	48 83 f8 08          	cmp    $0x8,%rax
  404d77:	0f 85 73 fc ff ff    	jne    4049f0 <fc_solve_sfs_move_cards_to_a_different_parent+0xa0>
    sort_derived_states(derived_states_list, derived_start_idx);
  404d7d:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  404d82:	48 63 94 24 98 00 00 	movslq 0x98(%rsp),%rdx
  404d89:	00 
  404d8a:	48 8b 70 08          	mov    0x8(%rax),%rsi
    const_AUTO(limit, d->states + d->num_states);
  404d8e:	48 8b 00             	mov    (%rax),%rax
    var_AUTO(start, d->states + derived_start_idx);
  404d91:	48 c1 e2 04          	shl    $0x4,%rdx
  404d95:	48 01 f2             	add    %rsi,%rdx
    for (var_AUTO(b, start + 1); b < limit; b++)
  404d98:	48 8d 4a 10          	lea    0x10(%rdx),%rcx
    const_AUTO(limit, d->states + d->num_states);
  404d9c:	48 c1 e0 04          	shl    $0x4,%rax
  404da0:	48 01 c6             	add    %rax,%rsi
    for (var_AUTO(b, start + 1); b < limit; b++)
  404da3:	48 39 ce             	cmp    %rcx,%rsi
  404da6:	76 45                	jbe    404ded <fc_solve_sfs_move_cards_to_a_different_parent+0x49d>
  404da8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  404daf:	00 
        for (var_AUTO(c, b); (c > start) && (c[0].context.i < c[-1].context.i);
  404db0:	8b 41 08             	mov    0x8(%rcx),%eax
  404db3:	39 41 f8             	cmp    %eax,-0x8(%rcx)
  404db6:	7e 2c                	jle    404de4 <fc_solve_sfs_move_cards_to_a_different_parent+0x494>
  404db8:	48 89 c8             	mov    %rcx,%rax
  404dbb:	eb 0b                	jmp    404dc8 <fc_solve_sfs_move_cards_to_a_different_parent+0x478>
  404dbd:	0f 1f 00             	nopl   (%rax)
  404dc0:	8b 58 08             	mov    0x8(%rax),%ebx
  404dc3:	39 58 f8             	cmp    %ebx,-0x8(%rax)
  404dc6:	7e 1c                	jle    404de4 <fc_solve_sfs_move_cards_to_a_different_parent+0x494>
            const_AUTO(swap_temp, c[-1]);
  404dc8:	c5 fa 6f 40 f0       	vmovdqu -0x10(%rax),%xmm0
             c--)
  404dcd:	48 83 e8 10          	sub    $0x10,%rax
            c[-1] = c[0];
  404dd1:	c5 fa 6f 48 10       	vmovdqu 0x10(%rax),%xmm1
            c[0] = swap_temp;
  404dd6:	c5 f8 11 40 10       	vmovups %xmm0,0x10(%rax)
            c[-1] = c[0];
  404ddb:	c5 f8 11 08          	vmovups %xmm1,(%rax)
        for (var_AUTO(c, b); (c > start) && (c[0].context.i < c[-1].context.i);
  404ddf:	48 39 c2             	cmp    %rax,%rdx
  404de2:	72 dc                	jb     404dc0 <fc_solve_sfs_move_cards_to_a_different_parent+0x470>
    for (var_AUTO(b, start + 1); b < limit; b++)
  404de4:	48 83 c1 10          	add    $0x10,%rcx
  404de8:	48 39 ce             	cmp    %rcx,%rsi
  404deb:	77 c3                	ja     404db0 <fc_solve_sfs_move_cards_to_a_different_parent+0x460>
}
  404ded:	48 81 c4 d8 00 00 00 	add    $0xd8,%rsp
  404df4:	5b                   	pop    %rbx
  404df5:	5d                   	pop    %rbp
  404df6:	41 5c                	pop    %r12
  404df8:	41 5d                	pop    %r13
  404dfa:	41 5e                	pop    %r14
  404dfc:	41 5f                	pop    %r15
  404dfe:	c3                   	retq   
  404dff:	90                   	nop
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  404e00:	4c 8b ac 24 b0 00 00 	mov    0xb0(%rsp),%r13
  404e07:	00 
  404e08:	e9 ed fe ff ff       	jmpq   404cfa <fc_solve_sfs_move_cards_to_a_different_parent+0x3aa>
  404e0d:	0f 1f 00             	nopl   (%rax)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  404e10:	48 8d 72 10          	lea    0x10(%rdx),%rsi
  404e14:	48 c1 e6 04          	shl    $0x4,%rsi
  404e18:	e8 53 c3 ff ff       	callq  401170 <realloc@plt>
  404e1d:	48 89 c7             	mov    %rax,%rdi
        list->states =
  404e20:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  404e25:	48 89 78 08          	mov    %rdi,0x8(%rax)
  404e29:	48 8b 00             	mov    (%rax),%rax
  404e2c:	e9 e9 fe ff ff       	jmpq   404d1a <fc_solve_sfs_move_cards_to_a_different_parent+0x3ca>
  404e31:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404e38:	00 00 00 00 
  404e3c:	0f 1f 40 00          	nopl   0x0(%rax)
                copy_two_stacks(stack_idx, ds);
  404e40:	4b 8b 34 e8          	mov    (%r8,%r13,8),%rsi
  404e44:	44 0f ab d0          	bts    %r10d,%eax
  404e48:	89 42 14             	mov    %eax,0x14(%rdx)
  404e4b:	4c 89 e8             	mov    %r13,%rax
  404e4e:	48 c1 e0 07          	shl    $0x7,%rax
  404e52:	48 03 84 24 90 00 00 	add    0x90(%rsp),%rax
  404e59:	00 
  404e5a:	0f be 16             	movsbl (%rsi),%edx
  404e5d:	83 c2 01             	add    $0x1,%edx
  404e60:	48 63 d2             	movslq %edx,%rdx
  404e63:	48 83 fa 08          	cmp    $0x8,%rdx
  404e67:	0f 83 b3 03 00 00    	jae    405220 <fc_solve_sfs_move_cards_to_a_different_parent+0x8d0>
  404e6d:	f6 c2 04             	test   $0x4,%dl
  404e70:	0f 85 40 04 00 00    	jne    4052b6 <fc_solve_sfs_move_cards_to_a_different_parent+0x966>
  404e76:	48 85 d2             	test   %rdx,%rdx
  404e79:	74 16                	je     404e91 <fc_solve_sfs_move_cards_to_a_different_parent+0x541>
  404e7b:	0f b6 0e             	movzbl (%rsi),%ecx
  404e7e:	88 08                	mov    %cl,(%rax)
  404e80:	4c 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%r8
  404e87:	00 
  404e88:	f6 c2 02             	test   $0x2,%dl
  404e8b:	0f 85 73 04 00 00    	jne    405304 <fc_solve_sfs_move_cards_to_a_different_parent+0x9b4>
  404e91:	4b 89 04 e8          	mov    %rax,(%r8,%r13,8)
  404e95:	e9 49 fd ff ff       	jmpq   404be3 <fc_solve_sfs_move_cards_to_a_different_parent+0x293>
  404e9a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  404ea0:	0b 44 24 4c          	or     0x4c(%rsp),%eax
  404ea4:	4c 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%r8
  404eab:	00 
  404eac:	89 42 14             	mov    %eax,0x14(%rdx)
  404eaf:	48 63 84 24 8c 00 00 	movslq 0x8c(%rsp),%rax
  404eb6:	00 
  404eb7:	49 8b 34 c0          	mov    (%r8,%rax,8),%rsi
  404ebb:	0f be 0e             	movsbl (%rsi),%ecx
  404ebe:	83 c1 01             	add    $0x1,%ecx
  404ec1:	48 63 c9             	movslq %ecx,%rcx
  404ec4:	48 83 f9 08          	cmp    $0x8,%rcx
  404ec8:	0f 83 32 03 00 00    	jae    405200 <fc_solve_sfs_move_cards_to_a_different_parent+0x8b0>
  404ece:	f6 c1 04             	test   $0x4,%cl
  404ed1:	0f 85 b9 03 00 00    	jne    405290 <fc_solve_sfs_move_cards_to_a_different_parent+0x940>
  404ed7:	48 85 c9             	test   %rcx,%rcx
  404eda:	74 23                	je     404eff <fc_solve_sfs_move_cards_to_a_different_parent+0x5af>
  404edc:	0f b6 16             	movzbl (%rsi),%edx
  404edf:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  404ee4:	88 17                	mov    %dl,(%rdi)
  404ee6:	f6 c1 02             	test   $0x2,%cl
  404ee9:	0f 85 f1 03 00 00    	jne    4052e0 <fc_solve_sfs_move_cards_to_a_different_parent+0x990>
  404eef:	48 8b 94 24 b8 00 00 	mov    0xb8(%rsp),%rdx
  404ef6:	00 
  404ef7:	4c 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%r8
  404efe:	00 
  404eff:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  404f04:	49 89 3c c0          	mov    %rdi,(%r8,%rax,8)
  404f08:	8b 42 14             	mov    0x14(%rdx),%eax
  404f0b:	e9 c9 fc ff ff       	jmpq   404bd9 <fc_solve_sfs_move_cards_to_a_different_parent+0x289>
        int dest_fc_idx = 0;
  404f10:	31 c9                	xor    %ecx,%ecx
            while ((*col_num_cards) == 0)
  404f12:	31 ff                	xor    %edi,%edi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  404f14:	4d 63 d6             	movslq %r14d,%r10
  404f17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  404f1e:	00 00 
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  404f20:	48 63 f1             	movslq %ecx,%rsi
  404f23:	41 80 7c 30 40 00    	cmpb   $0x0,0x40(%r8,%rsi,1)
  404f29:	0f 84 43 02 00 00    	je     405172 <fc_solve_sfs_move_cards_to_a_different_parent+0x822>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  404f2f:	8d 41 01             	lea    0x1(%rcx),%eax
  404f32:	83 f8 04             	cmp    $0x4,%eax
  404f35:	74 35                	je     404f6c <fc_solve_sfs_move_cards_to_a_different_parent+0x61c>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  404f37:	48 63 f0             	movslq %eax,%rsi
  404f3a:	41 80 7c 30 40 00    	cmpb   $0x0,0x40(%r8,%rsi,1)
  404f40:	0f 84 2a 02 00 00    	je     405170 <fc_solve_sfs_move_cards_to_a_different_parent+0x820>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  404f46:	8d 41 02             	lea    0x2(%rcx),%eax
  404f49:	83 f8 04             	cmp    $0x4,%eax
  404f4c:	74 1e                	je     404f6c <fc_solve_sfs_move_cards_to_a_different_parent+0x61c>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  404f4e:	48 63 f0             	movslq %eax,%rsi
  404f51:	41 80 7c 30 40 00    	cmpb   $0x0,0x40(%r8,%rsi,1)
  404f57:	0f 84 13 02 00 00    	je     405170 <fc_solve_sfs_move_cards_to_a_different_parent+0x820>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  404f5d:	85 c9                	test   %ecx,%ecx
  404f5f:	75 0b                	jne    404f6c <fc_solve_sfs_move_cards_to_a_different_parent+0x61c>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  404f61:	41 80 78 43 00       	cmpb   $0x0,0x43(%r8)
  404f66:	0f 84 84 02 00 00    	je     4051f0 <fc_solve_sfs_move_cards_to_a_different_parent+0x8a0>
  404f6c:	40 84 ff             	test   %dil,%dil
  404f6f:	74 07                	je     404f78 <fc_solve_sfs_move_cards_to_a_different_parent+0x628>
  404f71:	89 94 24 c0 00 00 00 	mov    %edx,0xc0(%rsp)
    while ((*col_num_cards) == 0)
  404f78:	85 d2                	test   %edx,%edx
  404f7a:	0f 84 b0 fc ff ff    	je     404c30 <fc_solve_sfs_move_cards_to_a_different_parent+0x2e0>
    char *const indirect_stacks_buffer =
  404f80:	49 8d 83 00 01 00 00 	lea    0x100(%r11),%rax
    int put_cards_in_col_idx = 0;
  404f87:	45 31 d2             	xor    %r10d,%r10d
  404f8a:	48 8b 8c 24 b0 00 00 	mov    0xb0(%rsp),%rcx
  404f91:	00 
    char *const indirect_stacks_buffer =
  404f92:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404f97:	41 83 fa 08          	cmp    $0x8,%r10d
  404f9b:	0f 84 4f 01 00 00    	je     4050f0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7a0>
        if (fcs_state_col_is_empty(state, ret))
  404fa1:	49 63 c2             	movslq %r10d,%rax
  404fa4:	48 8b 04 c1          	mov    (%rcx,%rax,8),%rax
  404fa8:	80 38 00             	cmpb   $0x0,(%rax)
  404fab:	0f 84 d0 02 00 00    	je     405281 <fc_solve_sfs_move_cards_to_a_different_parent+0x931>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404fb1:	41 8d 42 01          	lea    0x1(%r10),%eax
  404fb5:	83 f8 08             	cmp    $0x8,%eax
  404fb8:	0f 84 32 01 00 00    	je     4050f0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7a0>
        if (fcs_state_col_is_empty(state, ret))
  404fbe:	4c 63 c8             	movslq %eax,%r9
  404fc1:	4a 8b 34 c9          	mov    (%rcx,%r9,8),%rsi
  404fc5:	80 3e 00             	cmpb   $0x0,(%rsi)
  404fc8:	0f 84 12 02 00 00    	je     4051e0 <fc_solve_sfs_move_cards_to_a_different_parent+0x890>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404fce:	41 8d 42 02          	lea    0x2(%r10),%eax
  404fd2:	83 f8 08             	cmp    $0x8,%eax
  404fd5:	0f 84 15 01 00 00    	je     4050f0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7a0>
        if (fcs_state_col_is_empty(state, ret))
  404fdb:	4c 63 c8             	movslq %eax,%r9
  404fde:	4a 8b 34 c9          	mov    (%rcx,%r9,8),%rsi
  404fe2:	80 3e 00             	cmpb   $0x0,(%rsi)
  404fe5:	0f 84 f5 01 00 00    	je     4051e0 <fc_solve_sfs_move_cards_to_a_different_parent+0x890>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404feb:	41 8d 42 03          	lea    0x3(%r10),%eax
  404fef:	83 f8 08             	cmp    $0x8,%eax
  404ff2:	0f 84 f8 00 00 00    	je     4050f0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7a0>
        if (fcs_state_col_is_empty(state, ret))
  404ff8:	4c 63 c8             	movslq %eax,%r9
  404ffb:	4a 8b 34 c9          	mov    (%rcx,%r9,8),%rsi
  404fff:	80 3e 00             	cmpb   $0x0,(%rsi)
  405002:	0f 84 d8 01 00 00    	je     4051e0 <fc_solve_sfs_move_cards_to_a_different_parent+0x890>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405008:	41 8d 42 04          	lea    0x4(%r10),%eax
  40500c:	83 f8 08             	cmp    $0x8,%eax
  40500f:	0f 84 db 00 00 00    	je     4050f0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7a0>
        if (fcs_state_col_is_empty(state, ret))
  405015:	4c 63 c8             	movslq %eax,%r9
  405018:	4a 8b 34 c9          	mov    (%rcx,%r9,8),%rsi
  40501c:	80 3e 00             	cmpb   $0x0,(%rsi)
  40501f:	0f 84 bb 01 00 00    	je     4051e0 <fc_solve_sfs_move_cards_to_a_different_parent+0x890>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405025:	41 8d 42 05          	lea    0x5(%r10),%eax
  405029:	83 f8 08             	cmp    $0x8,%eax
  40502c:	0f 84 be 00 00 00    	je     4050f0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7a0>
        if (fcs_state_col_is_empty(state, ret))
  405032:	4c 63 c8             	movslq %eax,%r9
  405035:	4a 8b 34 c9          	mov    (%rcx,%r9,8),%rsi
  405039:	80 3e 00             	cmpb   $0x0,(%rsi)
  40503c:	0f 84 9e 01 00 00    	je     4051e0 <fc_solve_sfs_move_cards_to_a_different_parent+0x890>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405042:	41 8d 42 06          	lea    0x6(%r10),%eax
  405046:	83 f8 08             	cmp    $0x8,%eax
  405049:	0f 84 a1 00 00 00    	je     4050f0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7a0>
        if (fcs_state_col_is_empty(state, ret))
  40504f:	4c 63 c8             	movslq %eax,%r9
  405052:	4a 8b 34 c9          	mov    (%rcx,%r9,8),%rsi
  405056:	80 3e 00             	cmpb   $0x0,(%rsi)
  405059:	0f 84 81 01 00 00    	je     4051e0 <fc_solve_sfs_move_cards_to_a_different_parent+0x890>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40505f:	45 85 d2             	test   %r10d,%r10d
  405062:	0f 85 88 00 00 00    	jne    4050f0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7a0>
        if (fcs_state_col_is_empty(state, ret))
  405068:	48 8b 49 38          	mov    0x38(%rcx),%rcx
    return -1;
  40506c:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
  405071:	49 c7 c1 ff ff ff ff 	mov    $0xffffffffffffffff,%r9
        if (fcs_state_col_is_empty(state, ret))
  405078:	80 39 00             	cmpb   $0x0,(%rcx)
  40507b:	0f 84 52 01 00 00    	je     4051d3 <fc_solve_sfs_move_cards_to_a_different_parent+0x883>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  405081:	48 8b b4 24 b8 00 00 	mov    0xb8(%rsp),%rsi
  405088:	00 
  405089:	8b 4e 14             	mov    0x14(%rsi),%ecx
  40508c:	0f a3 c1             	bt     %eax,%ecx
  40508f:	0f 83 7e 00 00 00    	jae    405113 <fc_solve_sfs_move_cards_to_a_different_parent+0x7c3>
  405095:	4b 8b 34 f0          	mov    (%r8,%r14,8),%rsi
    fcs_col_pop_card(col, ret);
  405099:	0f be 0e             	movsbl (%rsi),%ecx
  40509c:	89 c8                	mov    %ecx,%eax
  40509e:	83 e9 01             	sub    $0x1,%ecx
  4050a1:	83 e8 01             	sub    $0x1,%eax
  4050a4:	48 63 c9             	movslq %ecx,%rcx
        --(*col_num_cards);
  4050a7:	83 ea 01             	sub    $0x1,%edx
  4050aa:	0f b6 4c 0e 01       	movzbl 0x1(%rsi,%rcx,1),%ecx
  4050af:	88 06                	mov    %al,(%rsi)
  4050b1:	48 0f be c0          	movsbq %al,%rax
  4050b5:	c6 44 06 01 00       	movb   $0x0,0x1(%rsi,%rax,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  4050ba:	4b 8b 34 c8          	mov    (%r8,%r9,8),%rsi
    fcs_col_push_card(col, card);
  4050be:	48 0f be 06          	movsbq (%rsi),%rax
  4050c2:	8d 78 01             	lea    0x1(%rax),%edi
  4050c5:	40 88 3e             	mov    %dil,(%rsi)
  4050c8:	88 4c 06 01          	mov    %cl,0x1(%rsi,%rax,1)
  4050cc:	48 8b 8c 24 b0 00 00 	mov    0xb0(%rsp),%rcx
  4050d3:	00 
  4050d4:	89 94 24 c0 00 00 00 	mov    %edx,0xc0(%rsp)
        while ((*col_num_cards) == 0)
  4050db:	0f 84 57 fb ff ff    	je     404c38 <fc_solve_sfs_move_cards_to_a_different_parent+0x2e8>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4050e1:	41 83 fa 08          	cmp    $0x8,%r10d
  4050e5:	0f 85 b6 fe ff ff    	jne    404fa1 <fc_solve_sfs_move_cards_to_a_different_parent+0x651>
  4050eb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4050f0:	48 8b b4 24 b8 00 00 	mov    0xb8(%rsp),%rsi
  4050f7:	00 
    return -1;
  4050f8:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4050fd:	45 31 d2             	xor    %r10d,%r10d
  405100:	49 c7 c1 ff ff ff ff 	mov    $0xffffffffffffffff,%r9
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  405107:	8b 4e 14             	mov    0x14(%rsi),%ecx
  40510a:	0f a3 c1             	bt     %eax,%ecx
  40510d:	0f 82 82 ff ff ff    	jb     405095 <fc_solve_sfs_move_cards_to_a_different_parent+0x745>
  405113:	4f 8d 1c c8          	lea    (%r8,%r9,8),%r11
  405117:	0f ab c1             	bts    %eax,%ecx
  40511a:	c1 e0 07             	shl    $0x7,%eax
  40511d:	89 4e 14             	mov    %ecx,0x14(%rsi)
  405120:	49 8b 33             	mov    (%r11),%rsi
  405123:	48 98                	cltq   
  405125:	48 03 44 24 10       	add    0x10(%rsp),%rax
  40512a:	0f be 0e             	movsbl (%rsi),%ecx
  40512d:	83 c1 01             	add    $0x1,%ecx
  405130:	48 63 c9             	movslq %ecx,%rcx
  405133:	48 83 f9 08          	cmp    $0x8,%rcx
  405137:	0f 83 13 01 00 00    	jae    405250 <fc_solve_sfs_move_cards_to_a_different_parent+0x900>
  40513d:	f6 c1 04             	test   $0x4,%cl
  405140:	0f 85 89 01 00 00    	jne    4052cf <fc_solve_sfs_move_cards_to_a_different_parent+0x97f>
  405146:	48 85 c9             	test   %rcx,%rcx
  405149:	74 0f                	je     40515a <fc_solve_sfs_move_cards_to_a_different_parent+0x80a>
  40514b:	0f b6 3e             	movzbl (%rsi),%edi
  40514e:	40 88 38             	mov    %dil,(%rax)
  405151:	f6 c1 02             	test   $0x2,%cl
  405154:	0f 85 c1 01 00 00    	jne    40531b <fc_solve_sfs_move_cards_to_a_different_parent+0x9cb>
  40515a:	49 89 03             	mov    %rax,(%r11)
  40515d:	e9 33 ff ff ff       	jmpq   405095 <fc_solve_sfs_move_cards_to_a_different_parent+0x745>
  405162:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  405169:	00 00 00 00 
  40516d:	0f 1f 00             	nopl   (%rax)
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405170:	89 c1                	mov    %eax,%ecx
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  405172:	4b 8b 3c d0          	mov    (%r8,%r10,8),%rdi
            ++dest_fc_idx;
  405176:	83 c1 01             	add    $0x1,%ecx
    fcs_col_pop_card(col, ret);
  405179:	44 0f be 0f          	movsbl (%rdi),%r9d
  40517d:	44 89 c8             	mov    %r9d,%eax
  405180:	41 83 e9 01          	sub    $0x1,%r9d
  405184:	4d 63 c9             	movslq %r9d,%r9
  405187:	83 e8 01             	sub    $0x1,%eax
  40518a:	46 0f b6 4c 0f 01    	movzbl 0x1(%rdi,%r9,1),%r9d
  405190:	88 07                	mov    %al,(%rdi)
  405192:	48 0f be c0          	movsbq %al,%rax
  405196:	c6 44 07 01 00       	movb   $0x0,0x1(%rdi,%rax,1)
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  40519b:	45 88 4c 30 40       	mov    %r9b,0x40(%r8,%rsi,1)
            while ((*col_num_cards) == 0)
  4051a0:	83 ea 01             	sub    $0x1,%edx
  4051a3:	0f 84 87 fa ff ff    	je     404c30 <fc_solve_sfs_move_cards_to_a_different_parent+0x2e0>
  4051a9:	bf 01 00 00 00       	mov    $0x1,%edi
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4051ae:	83 f9 04             	cmp    $0x4,%ecx
  4051b1:	0f 85 69 fd ff ff    	jne    404f20 <fc_solve_sfs_move_cards_to_a_different_parent+0x5d0>
  4051b7:	e9 b5 fd ff ff       	jmpq   404f71 <fc_solve_sfs_move_cards_to_a_different_parent+0x621>
  4051bc:	0f 1f 40 00          	nopl   0x0(%rax)
  4051c0:	49 8b 85 f0 00 00 00 	mov    0xf0(%r13),%rax
  4051c7:	49 89 85 e8 00 00 00 	mov    %rax,0xe8(%r13)
  4051ce:	e9 1f fb ff ff       	jmpq   404cf2 <fc_solve_sfs_move_cards_to_a_different_parent+0x3a2>
        if (fcs_state_col_is_empty(state, ret))
  4051d3:	b8 07 00 00 00       	mov    $0x7,%eax
  4051d8:	41 b9 07 00 00 00    	mov    $0x7,%r9d
  4051de:	66 90                	xchg   %ax,%ax
  4051e0:	44 8d 50 01          	lea    0x1(%rax),%r10d
  4051e4:	e9 98 fe ff ff       	jmpq   405081 <fc_solve_sfs_move_cards_to_a_different_parent+0x731>
  4051e9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4051f0:	b9 03 00 00 00       	mov    $0x3,%ecx
  4051f5:	be 03 00 00 00       	mov    $0x3,%esi
  4051fa:	e9 73 ff ff ff       	jmpq   405172 <fc_solve_sfs_move_cards_to_a_different_parent+0x822>
  4051ff:	90                   	nop
                copy_two_stacks(stack_idx, ds);
  405200:	48 8b 54 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdx
  405205:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  40520a:	48 89 54 0f f8       	mov    %rdx,-0x8(%rdi,%rcx,1)
  40520f:	48 83 e9 01          	sub    $0x1,%rcx
  405213:	48 c1 e9 03          	shr    $0x3,%rcx
  405217:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40521a:	e9 d0 fc ff ff       	jmpq   404eef <fc_solve_sfs_move_cards_to_a_different_parent+0x59f>
  40521f:	90                   	nop
  405220:	48 8b 4c 16 f8       	mov    -0x8(%rsi,%rdx,1),%rcx
  405225:	48 89 c7             	mov    %rax,%rdi
  405228:	48 89 4c 10 f8       	mov    %rcx,-0x8(%rax,%rdx,1)
  40522d:	48 8d 4a ff          	lea    -0x1(%rdx),%rcx
  405231:	48 c1 e9 03          	shr    $0x3,%rcx
  405235:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405238:	4c 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%r8
  40523f:	00 
  405240:	e9 4c fc ff ff       	jmpq   404e91 <fc_solve_sfs_move_cards_to_a_different_parent+0x541>
  405245:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40524c:	00 00 00 00 
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  405250:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  405255:	48 89 7c 08 f8       	mov    %rdi,-0x8(%rax,%rcx,1)
  40525a:	48 83 e9 01          	sub    $0x1,%rcx
  40525e:	48 89 c7             	mov    %rax,%rdi
  405261:	48 c1 e9 03          	shr    $0x3,%rcx
  405265:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405268:	e9 ed fe ff ff       	jmpq   40515a <fc_solve_sfs_move_cards_to_a_different_parent+0x80a>
        min_card_height += 2;
  40526d:	41 83 c0 02          	add    $0x2,%r8d
        for (int c = min_card_height; c < cards_num; c++)
  405271:	44 39 44 24 64       	cmp    %r8d,0x64(%rsp)
  405276:	0f 8f f5 f7 ff ff    	jg     404a71 <fc_solve_sfs_move_cards_to_a_different_parent+0x121>
  40527c:	e9 e9 fa ff ff       	jmpq   404d6a <fc_solve_sfs_move_cards_to_a_different_parent+0x41a>
        if (fcs_state_col_is_empty(state, ret))
  405281:	4d 63 ca             	movslq %r10d,%r9
  405284:	41 83 c2 01          	add    $0x1,%r10d
  405288:	4c 89 c8             	mov    %r9,%rax
  40528b:	e9 f1 fd ff ff       	jmpq   405081 <fc_solve_sfs_move_cards_to_a_different_parent+0x731>
                copy_two_stacks(stack_idx, ds);
  405290:	8b 16                	mov    (%rsi),%edx
  405292:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  405297:	89 17                	mov    %edx,(%rdi)
  405299:	8b 54 0e fc          	mov    -0x4(%rsi,%rcx,1),%edx
  40529d:	89 54 0f fc          	mov    %edx,-0x4(%rdi,%rcx,1)
  4052a1:	48 8b 94 24 b8 00 00 	mov    0xb8(%rsp),%rdx
  4052a8:	00 
  4052a9:	4c 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%r8
  4052b0:	00 
  4052b1:	e9 49 fc ff ff       	jmpq   404eff <fc_solve_sfs_move_cards_to_a_different_parent+0x5af>
  4052b6:	8b 0e                	mov    (%rsi),%ecx
  4052b8:	89 08                	mov    %ecx,(%rax)
  4052ba:	8b 4c 16 fc          	mov    -0x4(%rsi,%rdx,1),%ecx
  4052be:	89 4c 10 fc          	mov    %ecx,-0x4(%rax,%rdx,1)
  4052c2:	4c 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%r8
  4052c9:	00 
  4052ca:	e9 c2 fb ff ff       	jmpq   404e91 <fc_solve_sfs_move_cards_to_a_different_parent+0x541>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4052cf:	8b 3e                	mov    (%rsi),%edi
  4052d1:	89 38                	mov    %edi,(%rax)
  4052d3:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  4052d7:	89 74 08 fc          	mov    %esi,-0x4(%rax,%rcx,1)
  4052db:	e9 7a fe ff ff       	jmpq   40515a <fc_solve_sfs_move_cards_to_a_different_parent+0x80a>
                copy_two_stacks(stack_idx, ds);
  4052e0:	0f b7 54 0e fe       	movzwl -0x2(%rsi,%rcx,1),%edx
  4052e5:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  4052ea:	66 89 54 0f fe       	mov    %dx,-0x2(%rdi,%rcx,1)
  4052ef:	48 8b 94 24 b8 00 00 	mov    0xb8(%rsp),%rdx
  4052f6:	00 
  4052f7:	4c 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%r8
  4052fe:	00 
  4052ff:	e9 fb fb ff ff       	jmpq   404eff <fc_solve_sfs_move_cards_to_a_different_parent+0x5af>
  405304:	0f b7 4c 16 fe       	movzwl -0x2(%rsi,%rdx,1),%ecx
  405309:	66 89 4c 10 fe       	mov    %cx,-0x2(%rax,%rdx,1)
  40530e:	4c 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%r8
  405315:	00 
  405316:	e9 76 fb ff ff       	jmpq   404e91 <fc_solve_sfs_move_cards_to_a_different_parent+0x541>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  40531b:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  405320:	66 89 74 08 fe       	mov    %si,-0x2(%rax,%rcx,1)
  405325:	e9 30 fe ff ff       	jmpq   40515a <fc_solve_sfs_move_cards_to_a_different_parent+0x80a>
  40532a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

0000000000405330 <fc_solve_sfs_move_fc_to_empty_and_put_on_top>:
    const fcs_game_limit num_vacant_stacks = soft_thread->num_vacant_stacks;
  405330:	0f b6 87 e3 01 00 00 	movzbl 0x1e3(%rdi),%eax
    if (!num_vacant_stacks)
  405337:	84 c0                	test   %al,%al
  405339:	0f 84 73 05 00 00    	je     4058b2 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x582>
{
  40533f:	41 57                	push   %r15
  405341:	49 89 c9             	mov    %rcx,%r9
  405344:	41 56                	push   %r14
  405346:	41 55                	push   %r13
  405348:	41 54                	push   %r12
  40534a:	55                   	push   %rbp
  40534b:	53                   	push   %rbx
  40534c:	48 81 ec c8 00 00 00 	sub    $0xc8,%rsp
    SET_empty_stack_idx(empty_stack_idx);
  405353:	48 8b 0e             	mov    (%rsi),%rcx
  405356:	80 39 00             	cmpb   $0x0,(%rcx)
  405359:	0f 84 2b 0c 00 00    	je     405f8a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc5a>
  40535f:	48 8b 4e 08          	mov    0x8(%rsi),%rcx
  405363:	80 39 00             	cmpb   $0x0,(%rcx)
  405366:	0f 84 28 0c 00 00    	je     405f94 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc64>
  40536c:	48 8b 4e 10          	mov    0x10(%rsi),%rcx
  405370:	80 39 00             	cmpb   $0x0,(%rcx)
  405373:	0f 84 07 0c 00 00    	je     405f80 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc50>
  405379:	48 8b 4e 18          	mov    0x18(%rsi),%rcx
  40537d:	80 39 00             	cmpb   $0x0,(%rcx)
  405380:	0f 84 18 0c 00 00    	je     405f9e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc6e>
  405386:	48 8b 4e 20          	mov    0x20(%rsi),%rcx
  40538a:	80 39 00             	cmpb   $0x0,(%rcx)
  40538d:	0f 84 c4 0b 00 00    	je     405f57 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc27>
  405393:	48 8b 4e 28          	mov    0x28(%rsi),%rcx
  405397:	80 39 00             	cmpb   $0x0,(%rcx)
  40539a:	0f 84 08 0c 00 00    	je     405fa8 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc78>
  4053a0:	48 8b 4e 30          	mov    0x30(%rsi),%rcx
  4053a4:	80 39 00             	cmpb   $0x0,(%rcx)
  4053a7:	0f 84 05 0c 00 00    	je     405fb2 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc82>
  4053ad:	48 8b 4e 38          	mov    0x38(%rsi),%rcx
  4053b1:	c7 44 24 4c 00 01 00 	movl   $0x100,0x4c(%rsp)
  4053b8:	00 
  4053b9:	41 b8 00 04 00 00    	mov    $0x400,%r8d
  4053bf:	c7 44 24 48 08 00 00 	movl   $0x8,0x48(%rsp)
  4053c6:	00 
  4053c7:	80 39 00             	cmpb   $0x0,(%rcx)
  4053ca:	0f 84 ec 0b 00 00    	je     405fbc <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc8c>
  4053d0:	48 89 74 24 10       	mov    %rsi,0x10(%rsp)
    MOVE_FUNCS__define_common();
  4053d5:	48 8b 37             	mov    (%rdi),%rsi
    const fcs_game_limit num_virtual_vacant_stacks = num_vacant_stacks - 1;
  4053d8:	83 e8 01             	sub    $0x1,%eax
  4053db:	48 89 7c 24 40       	mov    %rdi,0x40(%rsp)
    const fcs_game_limit num_virtual_vacant_freecells =
  4053e0:	0f b6 bf e4 01 00 00 	movzbl 0x1e4(%rdi),%edi
    const fcs_game_limit num_virtual_vacant_stacks = num_vacant_stacks - 1;
  4053e7:	88 44 24 33          	mov    %al,0x33(%rsp)
  4053eb:	4c 89 4c 24 38       	mov    %r9,0x38(%rsp)
    MOVE_FUNCS__define_common();
  4053f0:	48 8d 86 00 01 00 00 	lea    0x100(%rsi),%rax
  4053f7:	48 89 54 24 78       	mov    %rdx,0x78(%rsp)
    const fcs_game_limit num_virtual_vacant_freecells =
  4053fc:	44 8d 4f 01          	lea    0x1(%rdi),%r9d
            my_copy_stack(empty_stack_idx);
  405400:	49 01 c0             	add    %rax,%r8
    MOVE_FUNCS__define_common();
  405403:	48 89 74 24 70       	mov    %rsi,0x70(%rsp)
    const fcs_game_limit num_virtual_vacant_freecells =
  405408:	40 88 7c 24 04       	mov    %dil,0x4(%rsp)
    return -1;
  40540d:	45 89 cb             	mov    %r9d,%r11d
    MOVE_FUNCS__define_common();
  405410:	48 89 44 24 50       	mov    %rax,0x50(%rsp)
            my_copy_stack(empty_stack_idx);
  405415:	4c 89 44 24 58       	mov    %r8,0x58(%rsp)
  40541a:	48 c7 44 24 08 03 00 	movq   $0x3,0x8(%rsp)
  405421:	00 00 
  405423:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
        const fcs_card src_card = fcs_freecell_card(state, fc);
  405428:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  40542d:	89 44 24 34          	mov    %eax,0x34(%rsp)
  405431:	0f b6 44 07 40       	movzbl 0x40(%rdi,%rax,1),%eax
  405436:	88 44 24 23          	mov    %al,0x23(%rsp)
        if (SHOULD_SKIP_FC_CARD(src_card))
  40543a:	84 c0                	test   %al,%al
  40543c:	75 32                	jne    405470 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x140>
  40543e:	48 83 6c 24 08 01    	subq   $0x1,0x8(%rsp)
  405444:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
    for (int fc = LOCAL_FREECELLS_NUM - 1; fc >= 0; --fc)
  405449:	48 83 f8 ff          	cmp    $0xffffffffffffffff,%rax
  40544d:	75 d4                	jne    405423 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xf3>
}
  40544f:	48 81 c4 c8 00 00 00 	add    $0xc8,%rsp
  405456:	5b                   	pop    %rbx
  405457:	5d                   	pop    %rbp
  405458:	41 5c                	pop    %r12
  40545a:	41 5d                	pop    %r13
  40545c:	41 5e                	pop    %r14
  40545e:	41 5f                	pop    %r15
  405460:	c3                   	retq   
  405461:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  405468:	00 00 00 00 
  40546c:	0f 1f 40 00          	nopl   0x0(%rax)
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  405470:	4c 0f be 64 24 23    	movsbq 0x23(%rsp),%r12
  405476:	49 89 ff             	mov    %rdi,%r15
        if (SHOULD_SKIP_FC_CARD(src_card))
  405479:	31 db                	xor    %ebx,%ebx
            sfs_check_state_begin();
  40547b:	45 89 de             	mov    %r11d,%r14d
  40547e:	49 c1 e4 06          	shl    $0x6,%r12
  405482:	49 81 c4 c0 05 41 00 	add    $0x4105c0,%r12
  405489:	4c 63 eb             	movslq %ebx,%r13
            if (dest_fc == fc)
  40548c:	39 5c 24 08          	cmp    %ebx,0x8(%rsp)
  405490:	74 1a                	je     4054ac <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x17c>
            const fcs_card dest_card = fcs_freecell_card(state, dest_fc);
  405492:	41 0f b6 6c 1f 40    	movzbl 0x40(%r15,%rbx,1),%ebp
            if (fcs_card_is_empty(dest_card))
  405498:	40 84 ed             	test   %bpl,%bpl
  40549b:	74 0f                	je     4054ac <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x17c>
  40549d:	48 0f be c5          	movsbq %bpl,%rax
            if (!unlikely(fcs_is_parent_card(dest_card, src_card)))
  4054a1:	41 80 3c 04 00       	cmpb   $0x0,(%r12,%rax,1)
  4054a6:	0f 85 07 04 00 00    	jne    4058b3 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x583>
  4054ac:	48 83 c3 01          	add    $0x1,%rbx
        for (int dest_fc = 0; dest_fc < LOCAL_FREECELLS_NUM; ++dest_fc)
  4054b0:	48 83 fb 04          	cmp    $0x4,%rbx
  4054b4:	75 d3                	jne    405489 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x159>
  4054b6:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  4054bb:	45 31 c0             	xor    %r8d,%r8d
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  4054be:	45 89 f7             	mov    %r14d,%r15d
  4054c1:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
  4054c6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  4054cd:	00 00 00 
    ret.col = fcs_state_get_col(*s, stack_idx);
  4054d0:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
  4054d5:	44 89 44 24 04       	mov    %r8d,0x4(%rsp)
  4054da:	4a 8b 1c c0          	mov    (%rax,%r8,8),%rbx
    ret.col_len_minus_1 = (ret.col_len = fcs_col_len(ret.col)) - 1;
  4054de:	4c 0f be 1b          	movsbq (%rbx),%r11
  4054e2:	4d 8d 6b ff          	lea    -0x1(%r11),%r13
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4054e6:	4d 85 ed             	test   %r13,%r13
  4054e9:	0f 8e 71 03 00 00    	jle    405860 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x530>
  4054ef:	48 0f be 43 01       	movsbq 0x1(%rbx),%rax
  4054f4:	48 0f be 53 02       	movsbq 0x2(%rbx),%rdx
  4054f9:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  4054fd:	80 bc 02 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rdx,%rax,1)
  405504:	00 
  405505:	0f 84 55 03 00 00    	je     405860 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x530>
  40550b:	4c 89 ed             	mov    %r13,%rbp
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  40550e:	31 c0                	xor    %eax,%eax
  405510:	eb 2c                	jmp    40553e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x20e>
  405512:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  405519:	00 00 00 00 
  40551d:	0f 1f 00             	nopl   (%rax)
  405520:	48 0f be 54 03 01    	movsbq 0x1(%rbx,%rax,1),%rdx
  405526:	48 0f be 4c 03 02    	movsbq 0x2(%rbx,%rax,1),%rcx
  40552c:	48 c1 e2 06          	shl    $0x6,%rdx
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  405530:	80 bc 11 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rcx,%rdx,1)
  405537:	00 
  405538:	0f 84 12 03 00 00    	je     405850 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x520>
         ++((*iter).seq_end))
  40553e:	48 83 c0 01          	add    $0x1,%rax
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  405542:	4c 39 e8             	cmp    %r13,%rax
  405545:	75 d9                	jne    405520 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x1f0>
    return ret;
  405547:	0f b6 4c 24 04       	movzbl 0x4(%rsp),%ecx
  40554c:	b8 01 00 00 00       	mov    $0x1,%eax
  405551:	d3 e0                	shl    %cl,%eax
  405553:	89 44 24 24          	mov    %eax,0x24(%rsp)
            for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  405557:	4d 85 db             	test   %r11,%r11
  40555a:	0f 8e 98 00 00 00    	jle    4055f8 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x2c8>
  405560:	48 0f be 44 24 23    	movsbq 0x23(%rsp),%rax
    return ret;
  405566:	31 d2                	xor    %edx,%edx
  405568:	48 c1 e0 06          	shl    $0x6,%rax
  40556c:	4c 8d a0 c0 05 41 00 	lea    0x4105c0(%rax),%r12
  405573:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40557a:	00 00 00 00 
  40557e:	66 90                	xchg   %ax,%ax
  405580:	48 0f be 44 13 01    	movsbq 0x1(%rbx,%rdx,1),%rax
                if (!unlikely(fcs_is_parent_card(card, src_card)))
  405586:	41 80 3c 04 00       	cmpb   $0x0,(%r12,%rax,1)
  40558b:	0f 85 af 00 00 00    	jne    405640 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x310>
    iter->c = iter->seq_end + 1;
  405591:	48 8d 55 01          	lea    0x1(%rbp),%rdx
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  405595:	49 39 d5             	cmp    %rdx,%r13
  405598:	0f 8e 92 00 00 00    	jle    405630 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x300>
  40559e:	48 0f be 44 2b 02    	movsbq 0x2(%rbx,%rbp,1),%rax
  4055a4:	48 0f be 4c 2b 03    	movsbq 0x3(%rbx,%rbp,1),%rcx
  4055aa:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  4055ae:	80 bc 01 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rcx,%rax,1)
  4055b5:	00 
  4055b6:	74 78                	je     405630 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x300>
  4055b8:	49 8d 6b ff          	lea    -0x1(%r11),%rbp
  4055bc:	48 89 d0             	mov    %rdx,%rax
  4055bf:	eb 29                	jmp    4055ea <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x2ba>
  4055c1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4055c8:	00 00 00 00 
  4055cc:	0f 1f 40 00          	nopl   0x0(%rax)
  4055d0:	48 0f be 4c 03 01    	movsbq 0x1(%rbx,%rax,1),%rcx
  4055d6:	48 0f be 74 03 02    	movsbq 0x2(%rbx,%rax,1),%rsi
  4055dc:	48 c1 e1 06          	shl    $0x6,%rcx
  4055e0:	80 bc 0e c0 05 41 00 	cmpb   $0x0,0x4105c0(%rsi,%rcx,1)
  4055e7:	00 
  4055e8:	74 36                	je     405620 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x2f0>
         ++((*iter).seq_end))
  4055ea:	48 83 c0 01          	add    $0x1,%rax
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4055ee:	48 39 e8             	cmp    %rbp,%rax
  4055f1:	75 dd                	jne    4055d0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x2a0>
            for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  4055f3:	49 39 d3             	cmp    %rdx,%r11
  4055f6:	7f 88                	jg     405580 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x250>
  4055f8:	48 83 6c 24 18 80    	subq   $0xffffffffffffff80,0x18(%rsp)
  4055fe:	49 83 c0 01          	add    $0x1,%r8
        for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; ++stack_idx)
  405602:	49 83 f8 08          	cmp    $0x8,%r8
  405606:	0f 85 c4 fe ff ff    	jne    4054d0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x1a0>
  40560c:	45 89 fb             	mov    %r15d,%r11d
  40560f:	e9 2a fe ff ff       	jmpq   40543e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x10e>
  405614:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40561b:	00 00 00 00 
  40561f:	90                   	nop
         ++((*iter).seq_end))
  405620:	48 89 c5             	mov    %rax,%rbp
            for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  405623:	49 39 d3             	cmp    %rdx,%r11
  405626:	0f 8f 54 ff ff ff    	jg     405580 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x250>
  40562c:	eb ca                	jmp    4055f8 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x2c8>
  40562e:	66 90                	xchg   %ax,%ax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  405630:	48 89 d5             	mov    %rdx,%rbp
            for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  405633:	49 39 d3             	cmp    %rdx,%r11
  405636:	0f 8f 44 ff ff ff    	jg     405580 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x250>
  40563c:	eb ba                	jmp    4055f8 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x2c8>
  40563e:	66 90                	xchg   %ax,%ax
                const int col_num_cards = iter.col_len_minus_1 - iter.seq_end;
  405640:	45 89 ee             	mov    %r13d,%r14d
    const fcs_game_limit freecells_to_fill =
  405643:	44 89 fe             	mov    %r15d,%esi
    return ((num_cards_to_relocate == 0) &&
  405646:	0f b6 7c 24 33       	movzbl 0x33(%rsp),%edi
                const int col_num_cards = iter.col_len_minus_1 - iter.seq_end;
  40564b:	41 29 ee             	sub    %ebp,%r14d
    const fcs_game_limit freecells_to_fill =
  40564e:	45 38 fe             	cmp    %r15b,%r14b
    num_cards_to_relocate -= freecells_to_fill;
  405651:	44 89 f1             	mov    %r14d,%ecx
    const fcs_game_limit freecells_to_fill =
  405654:	41 0f 46 f6          	cmovbe %r14d,%esi
    num_cards_to_relocate -= freecells_to_fill;
  405658:	29 f1                	sub    %esi,%ecx
    return ((num_cards_to_relocate == 0) &&
  40565a:	40 38 cf             	cmp    %cl,%dil
  40565d:	0f 82 2e ff ff ff    	jb     405591 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x261>
                iter->seq_end - iter->c + 1));
  405663:	48 89 e8             	mov    %rbp,%rax
            (calc_max_sequence_move(
  405666:	40 0f b6 f6          	movzbl %sil,%esi
                iter->seq_end - iter->c + 1));
  40566a:	48 29 d0             	sub    %rdx,%rax
  40566d:	48 89 c2             	mov    %rax,%rdx
  405670:	48 89 44 24 28       	mov    %rax,0x28(%rsp)
                if (!unlikely(check_if_can_relocate(col_num_cards,
  405675:	41 0f b6 c7          	movzbl %r15b,%eax
            (calc_max_sequence_move(
  405679:	29 f0                	sub    %esi,%eax
  40567b:	83 c0 01             	add    $0x1,%eax
    const fcs_game_limit freestacks_to_fill =
  40567e:	40 38 cf             	cmp    %cl,%dil
  405681:	0f 46 cf             	cmovbe %edi,%ecx
            (calc_max_sequence_move(
  405684:	29 cf                	sub    %ecx,%edi
  405686:	89 f9                	mov    %edi,%ecx
  405688:	d3 e0                	shl    %cl,%eax
  40568a:	48 98                	cltq   
    return ((num_cards_to_relocate == 0) &&
  40568c:	48 39 c2             	cmp    %rax,%rdx
  40568f:	0f 8d fc fe ff ff    	jge    405591 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x261>
                sfs_check_state_begin();
  405695:	48 8b 4c 24 78       	mov    0x78(%rsp),%rcx
  40569a:	48 8d b4 24 a0 00 00 	lea    0xa0(%rsp),%rsi
  4056a1:	00 
  4056a2:	4c 89 5c 24 68       	mov    %r11,0x68(%rsp)
  4056a7:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  4056ac:	4c 89 44 24 60       	mov    %r8,0x60(%rsp)
  4056b1:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  4056b6:	e8 65 c3 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
                copy_two_stacks(stack_idx, empty_stack_idx);
  4056bb:	48 8b 8c 24 a8 00 00 	mov    0xa8(%rsp),%rcx
  4056c2:	00 
  4056c3:	4c 8b 44 24 60       	mov    0x60(%rsp),%r8
  4056c8:	4c 8b 5c 24 68       	mov    0x68(%rsp),%r11
  4056cd:	8b 41 14             	mov    0x14(%rcx),%eax
  4056d0:	85 44 24 24          	test   %eax,0x24(%rsp)
  4056d4:	0f 84 66 03 00 00    	je     405a40 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x710>
  4056da:	48 8b 94 24 a0 00 00 	mov    0xa0(%rsp),%rdx
  4056e1:	00 
  4056e2:	48 63 7c 24 48       	movslq 0x48(%rsp),%rdi
  4056e7:	48 89 7c 24 68       	mov    %rdi,0x68(%rsp)
  4056ec:	48 8b 34 fa          	mov    (%rdx,%rdi,8),%rsi
  4056f0:	85 44 24 4c          	test   %eax,0x4c(%rsp)
  4056f4:	0f 84 e0 02 00 00    	je     4059da <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x6aa>
    fcs_col_push_card(col, card);
  4056fa:	48 0f be 06          	movsbq (%rsi),%rax
                const int col_num_cards = iter.col_len_minus_1 - iter.seq_end;
  4056fe:	44 89 f2             	mov    %r14d,%edx
                const int cols_indexes[3] = {stack_idx, -1, -1};
  405701:	48 c7 84 24 98 00 00 	movq   $0xffffffffffffffff,0x98(%rsp)
  405708:	00 ff ff ff ff 
  40570d:	0f b6 7c 24 23       	movzbl 0x23(%rsp),%edi
  405712:	8d 48 01             	lea    0x1(%rax),%ecx
  405715:	88 0e                	mov    %cl,(%rsi)
  405717:	40 88 7c 06 01       	mov    %dil,0x1(%rsi,%rax,1)
                fcs_empty_freecell(new_state_key, fc);
  40571c:	48 63 44 24 34       	movslq 0x34(%rsp),%rax
  405721:	4c 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%r9
  405728:	00 
  405729:	41 c6 44 01 40 00    	movb   $0x0,0x40(%r9,%rax,1)
                const int cols_indexes[3] = {stack_idx, -1, -1};
  40572f:	8b 44 24 04          	mov    0x4(%rsp),%eax
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  405733:	44 89 b4 24 b0 00 00 	mov    %r14d,0xb0(%rsp)
  40573a:	00 
                const int cols_indexes[3] = {stack_idx, -1, -1};
  40573b:	89 84 24 94 00 00 00 	mov    %eax,0x94(%rsp)
                empty_two_cols_from_new_state(soft_thread,
  405742:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  405747:	48 8b 00             	mov    (%rax),%rax
  40574a:	48 89 84 24 80 00 00 	mov    %rax,0x80(%rsp)
  405751:	00 
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  405752:	48 b8 00 00 00 00 ff 	movabs $0xffffffff00000000,%rax
  405759:	ff ff ff 
  40575c:	48 89 84 24 b4 00 00 	mov    %rax,0xb4(%rsp)
  405763:	00 
            while ((*col_num_cards) == 0)
  405764:	45 85 f6             	test   %r14d,%r14d
  405767:	0f 85 80 04 00 00    	jne    405bed <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x8bd>
  40576d:	0f 1f 00             	nopl   (%rax)
  405770:	48 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%rcx
  405777:	00 
  405778:	4a 8b 14 c1          	mov    (%rcx,%r8,8),%rdx
  40577c:	4c 89 9c 24 88 00 00 	mov    %r11,0x88(%rsp)
  405783:	00 
  405784:	48 8b 44 24 68       	mov    0x68(%rsp),%rax
  405789:	4c 89 84 24 80 00 00 	mov    %r8,0x80(%rsp)
  405790:	00 
                fcs_move_sequence(
  405791:	4c 8b 74 24 28       	mov    0x28(%rsp),%r14
  405796:	48 8b 0c c1          	mov    (%rcx,%rax,8),%rcx
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  40579a:	0f b6 02             	movzbl (%rdx),%eax
  40579d:	49 83 c6 01          	add    $0x1,%r14
    const size_t cards_size = (((size_t)cards_num) * sizeof(fcs_card));
  4057a1:	4d 63 d6             	movslq %r14d,%r10
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  4057a4:	4c 89 54 24 60       	mov    %r10,0x60(%rsp)
  4057a9:	48 89 4c 24 68       	mov    %rcx,0x68(%rsp)
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  4057ae:	44 29 f0             	sub    %r14d,%eax
  4057b1:	88 02                	mov    %al,(%rdx)
  4057b3:	48 0f be c0          	movsbq %al,%rax
    fcs_card *const src_cards_ptr =
  4057b7:	4c 8d 4c 02 01       	lea    0x1(%rdx,%rax,1),%r9
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  4057bc:	48 0f be 01          	movsbq (%rcx),%rax
  4057c0:	4c 89 d2             	mov    %r10,%rdx
  4057c3:	4c 89 ce             	mov    %r9,%rsi
  4057c6:	4c 89 4c 24 28       	mov    %r9,0x28(%rsp)
  4057cb:	48 8d 7c 01 01       	lea    0x1(%rcx,%rax,1),%rdi
  4057d0:	e8 0b b9 ff ff       	callq  4010e0 <memcpy@plt>
    fcs_col_len(dest_col) += cards_num;
  4057d5:	48 8b 4c 24 68       	mov    0x68(%rsp),%rcx
    memset(src_cards_ptr, 0, cards_size);
  4057da:	31 f6                	xor    %esi,%esi
  4057dc:	4c 8b 54 24 60       	mov    0x60(%rsp),%r10
  4057e1:	4c 8b 4c 24 28       	mov    0x28(%rsp),%r9
    fcs_col_len(dest_col) += cards_num;
  4057e6:	44 00 31             	add    %r14b,(%rcx)
    memset(src_cards_ptr, 0, cards_size);
  4057e9:	4c 89 d2             	mov    %r10,%rdx
  4057ec:	4c 89 cf             	mov    %r9,%rdi
  4057ef:	e8 ac b8 ff ff       	callq  4010a0 <memset@plt>
    const_SLOT(hard_thread, soft_thread);
  4057f4:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  4057f9:	48 8d 94 24 b0 00 00 	lea    0xb0(%rsp),%rdx
  405800:	00 
  405801:	48 8d b4 24 a0 00 00 	lea    0xa0(%rsp),%rsi
  405808:	00 
    const_SLOT(hard_thread, soft_thread);
  405809:	4c 8b 30             	mov    (%rax),%r14
    if (!fc_solve_check_and_add_state(
  40580c:	4c 89 f7             	mov    %r14,%rdi
  40580f:	e8 5c c3 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  405814:	4c 8b 84 24 80 00 00 	mov    0x80(%rsp),%r8
  40581b:	00 
  40581c:	84 c0                	test   %al,%al
  40581e:	4c 8b 9c 24 88 00 00 	mov    0x88(%rsp),%r11
  405825:	00 
  405826:	75 3f                	jne    405867 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x537>
        if (HT_FIELD(hard_thread, allocated_from_list))
  405828:	41 80 be 18 05 00 00 	cmpb   $0x0,0x518(%r14)
  40582f:	00 
  405830:	0f 85 b1 02 00 00    	jne    405ae7 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x7b7>
  405836:	49 8b 86 f0 00 00 00 	mov    0xf0(%r14),%rax
  40583d:	49 89 86 e8 00 00 00 	mov    %rax,0xe8(%r14)
        return FCS_STATE_kv_to_collectible(&existing_state);
  405844:	4c 8b b4 24 b0 00 00 	mov    0xb0(%rsp),%r14
  40584b:	00 
    return (fcs_collectible_state *)(s->key);
  40584c:	eb 21                	jmp    40586f <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x53f>
  40584e:	66 90                	xchg   %ax,%ax
         ++((*iter).seq_end))
  405850:	48 89 c5             	mov    %rax,%rbp
  405853:	e9 ef fc ff ff       	jmpq   405547 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x217>
  405858:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40585f:	00 
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  405860:	31 ed                	xor    %ebp,%ebp
  405862:	e9 e0 fc ff ff       	jmpq   405547 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x217>
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  405867:	4c 8b b4 24 a0 00 00 	mov    0xa0(%rsp),%r14
  40586e:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  40586f:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  405874:	31 c9                	xor    %ecx,%ecx
  405876:	48 8b 10             	mov    (%rax),%rdx
  405879:	48 8b 40 08          	mov    0x8(%rax),%rax
  40587d:	48 85 c0             	test   %rax,%rax
  405880:	0f 95 c1             	setne  %cl
  405883:	48 01 d1             	add    %rdx,%rcx
  405886:	f6 c1 0f             	test   $0xf,%cl
  405889:	0f 84 23 02 00 00    	je     405ab2 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x782>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  40588f:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  405894:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  405898:	48 c1 e2 04          	shl    $0x4,%rdx
  40589c:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4058a0:	48 01 d0             	add    %rdx,%rax
  4058a3:	48 89 0f             	mov    %rcx,(%rdi)
  4058a6:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4058aa:	4c 89 30             	mov    %r14,(%rax)
  4058ad:	e9 df fc ff ff       	jmpq   405591 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x261>
  4058b2:	c3                   	retq   
            sfs_check_state_begin();
  4058b3:	48 8b 4c 24 78       	mov    0x78(%rsp),%rcx
  4058b8:	4c 89 fa             	mov    %r15,%rdx
  4058bb:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  4058c0:	48 8d b4 24 a0 00 00 	lea    0xa0(%rsp),%rsi
  4058c7:	00 
  4058c8:	e8 53 c1 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
            my_copy_stack(empty_stack_idx);
  4058cd:	48 8b 94 24 a8 00 00 	mov    0xa8(%rsp),%rdx
  4058d4:	00 
  4058d5:	8b 42 14             	mov    0x14(%rdx),%eax
  4058d8:	85 44 24 4c          	test   %eax,0x4c(%rsp)
  4058dc:	0f 84 a9 02 00 00    	je     405b8b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x85b>
  4058e2:	48 63 54 24 48       	movslq 0x48(%rsp),%rdx
  4058e7:	48 8b 84 24 a0 00 00 	mov    0xa0(%rsp),%rax
  4058ee:	00 
  4058ef:	48 8b 0c d0          	mov    (%rax,%rdx,8),%rcx
    fcs_col_push_card(col, card);
  4058f3:	48 0f be 01          	movsbq (%rcx),%rax
  4058f7:	0f b6 7c 24 23       	movzbl 0x23(%rsp),%edi
  4058fc:	8d 70 01             	lea    0x1(%rax),%esi
  4058ff:	40 88 31             	mov    %sil,(%rcx)
    if (!fc_solve_check_and_add_state(
  405902:	48 8d b4 24 a0 00 00 	lea    0xa0(%rsp),%rsi
  405909:	00 
  40590a:	40 88 7c 01 01       	mov    %dil,0x1(%rcx,%rax,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  40590f:	48 8b 84 24 a0 00 00 	mov    0xa0(%rsp),%rax
  405916:	00 
  405917:	48 8b 14 d0          	mov    (%rax,%rdx,8),%rdx
    fcs_col_push_card(col, card);
  40591b:	48 0f be 02          	movsbq (%rdx),%rax
  40591f:	8d 48 01             	lea    0x1(%rax),%ecx
  405922:	88 0a                	mov    %cl,(%rdx)
  405924:	40 88 6c 02 01       	mov    %bpl,0x1(%rdx,%rax,1)
            fcs_empty_freecell(new_state_key, fc);
  405929:	48 63 54 24 34       	movslq 0x34(%rsp),%rdx
  40592e:	48 8b 84 24 a0 00 00 	mov    0xa0(%rsp),%rax
  405935:	00 
  405936:	c6 44 10 40 00       	movb   $0x0,0x40(%rax,%rdx,1)
  40593b:	48 8d 94 24 b0 00 00 	lea    0xb0(%rsp),%rdx
  405942:	00 
            fcs_empty_freecell(new_state_key, dest_fc);
  405943:	42 c6 44 28 40 00    	movb   $0x0,0x40(%rax,%r13,1)
    const_SLOT(hard_thread, soft_thread);
  405949:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  40594e:	48 8b 28             	mov    (%rax),%rbp
    if (!fc_solve_check_and_add_state(
  405951:	48 89 ef             	mov    %rbp,%rdi
  405954:	e8 17 c2 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  405959:	84 c0                	test   %al,%al
  40595b:	0f 85 57 05 00 00    	jne    405eb8 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb88>
        if (HT_FIELD(hard_thread, allocated_from_list))
  405961:	80 bd 18 05 00 00 00 	cmpb   $0x0,0x518(%rbp)
  405968:	0f 84 8f 05 00 00    	je     405efd <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xbcd>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  40596e:	48 8b 95 b0 00 00 00 	mov    0xb0(%rbp),%rdx
  405975:	48 8b 84 24 a8 00 00 	mov    0xa8(%rsp),%rax
  40597c:	00 
  40597d:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  405980:	48 8b 84 24 a0 00 00 	mov    0xa0(%rsp),%rax
  405987:	00 
  405988:	48 89 85 b0 00 00 00 	mov    %rax,0xb0(%rbp)
        return FCS_STATE_kv_to_collectible(&existing_state);
  40598f:	48 8b ac 24 b0 00 00 	mov    0xb0(%rsp),%rbp
  405996:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  405997:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  40599c:	31 c9                	xor    %ecx,%ecx
  40599e:	48 8b 10             	mov    (%rax),%rdx
  4059a1:	48 8b 40 08          	mov    0x8(%rax),%rax
  4059a5:	48 85 c0             	test   %rax,%rax
  4059a8:	0f 95 c1             	setne  %cl
  4059ab:	48 01 d1             	add    %rdx,%rcx
  4059ae:	f6 c1 0f             	test   $0xf,%cl
  4059b1:	0f 84 22 05 00 00    	je     405ed9 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xba9>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  4059b7:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  4059bc:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  4059c0:	48 c1 e2 04          	shl    $0x4,%rdx
  4059c4:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4059c8:	48 01 d0             	add    %rdx,%rax
  4059cb:	48 89 0f             	mov    %rcx,(%rdi)
  4059ce:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4059d2:	48 89 28             	mov    %rbp,(%rax)
  4059d5:	e9 d2 fa ff ff       	jmpq   4054ac <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x17c>
                copy_two_stacks(stack_idx, empty_stack_idx);
  4059da:	0b 44 24 4c          	or     0x4c(%rsp),%eax
  4059de:	89 41 14             	mov    %eax,0x14(%rcx)
  4059e1:	0f be 06             	movsbl (%rsi),%eax
  4059e4:	83 c0 01             	add    $0x1,%eax
  4059e7:	48 98                	cltq   
  4059e9:	48 83 f8 08          	cmp    $0x8,%rax
  4059ed:	0f 83 5d 01 00 00    	jae    405b50 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x820>
  4059f3:	a8 04                	test   $0x4,%al
  4059f5:	0f 85 13 06 00 00    	jne    40600e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xcde>
  4059fb:	48 85 c0             	test   %rax,%rax
  4059fe:	0f 84 71 01 00 00    	je     405b75 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x845>
  405a04:	0f b6 16             	movzbl (%rsi),%edx
  405a07:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  405a0c:	88 17                	mov    %dl,(%rdi)
  405a0e:	48 8b 94 24 a0 00 00 	mov    0xa0(%rsp),%rdx
  405a15:	00 
  405a16:	a8 02                	test   $0x2,%al
  405a18:	0f 84 57 01 00 00    	je     405b75 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x845>
  405a1e:	0f b7 54 06 fe       	movzwl -0x2(%rsi,%rax,1),%edx
  405a23:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  405a28:	66 89 54 07 fe       	mov    %dx,-0x2(%rdi,%rax,1)
  405a2d:	48 8b 94 24 a0 00 00 	mov    0xa0(%rsp),%rdx
  405a34:	00 
  405a35:	e9 3b 01 00 00       	jmpq   405b75 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x845>
  405a3a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  405a40:	0b 44 24 24          	or     0x24(%rsp),%eax
  405a44:	48 8b 94 24 a0 00 00 	mov    0xa0(%rsp),%rdx
  405a4b:	00 
  405a4c:	89 41 14             	mov    %eax,0x14(%rcx)
  405a4f:	48 63 44 24 04       	movslq 0x4(%rsp),%rax
  405a54:	48 8b 34 c2          	mov    (%rdx,%rax,8),%rsi
  405a58:	48 89 44 24 60       	mov    %rax,0x60(%rsp)
  405a5d:	0f be 06             	movsbl (%rsi),%eax
  405a60:	83 c0 01             	add    $0x1,%eax
  405a63:	48 98                	cltq   
  405a65:	48 83 f8 08          	cmp    $0x8,%rax
  405a69:	0f 82 9e 00 00 00    	jb     405b0d <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x7dd>
  405a6f:	48 8b 54 06 f8       	mov    -0x8(%rsi,%rax,1),%rdx
  405a74:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  405a79:	48 89 54 07 f8       	mov    %rdx,-0x8(%rdi,%rax,1)
  405a7e:	48 83 e8 01          	sub    $0x1,%rax
  405a82:	48 c1 e8 03          	shr    $0x3,%rax
  405a86:	48 89 c1             	mov    %rax,%rcx
  405a89:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405a8c:	48 8b 8c 24 a8 00 00 	mov    0xa8(%rsp),%rcx
  405a93:	00 
  405a94:	48 8b 94 24 a0 00 00 	mov    0xa0(%rsp),%rdx
  405a9b:	00 
  405a9c:	48 8b 44 24 60       	mov    0x60(%rsp),%rax
  405aa1:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  405aa6:	48 89 3c c2          	mov    %rdi,(%rdx,%rax,8)
  405aaa:	8b 41 14             	mov    0x14(%rcx),%eax
  405aad:	e9 30 fc ff ff       	jmpq   4056e2 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x3b2>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  405ab2:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  405ab6:	48 89 c7             	mov    %rax,%rdi
  405ab9:	4c 89 5c 24 60       	mov    %r11,0x60(%rsp)
  405abe:	48 c1 e6 04          	shl    $0x4,%rsi
  405ac2:	4c 89 44 24 28       	mov    %r8,0x28(%rsp)
  405ac7:	e8 a4 b6 ff ff       	callq  401170 <realloc@plt>
        list->states =
  405acc:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  405ad1:	4c 8b 5c 24 60       	mov    0x60(%rsp),%r11
  405ad6:	4c 8b 44 24 28       	mov    0x28(%rsp),%r8
  405adb:	48 89 47 08          	mov    %rax,0x8(%rdi)
  405adf:	48 8b 17             	mov    (%rdi),%rdx
  405ae2:	e9 a8 fd ff ff       	jmpq   40588f <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x55f>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  405ae7:	49 8b 96 b0 00 00 00 	mov    0xb0(%r14),%rdx
  405aee:	48 8b 84 24 a8 00 00 	mov    0xa8(%rsp),%rax
  405af5:	00 
  405af6:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  405af9:	48 8b 84 24 a0 00 00 	mov    0xa0(%rsp),%rax
  405b00:	00 
  405b01:	49 89 86 b0 00 00 00 	mov    %rax,0xb0(%r14)
  405b08:	e9 37 fd ff ff       	jmpq   405844 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x514>
  405b0d:	a8 04                	test   $0x4,%al
  405b0f:	0f 85 d3 04 00 00    	jne    405fe8 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xcb8>
  405b15:	48 85 c0             	test   %rax,%rax
  405b18:	74 82                	je     405a9c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x76c>
  405b1a:	0f b6 16             	movzbl (%rsi),%edx
  405b1d:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  405b22:	88 17                	mov    %dl,(%rdi)
  405b24:	a8 02                	test   $0x2,%al
  405b26:	0f 84 60 ff ff ff    	je     405a8c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x75c>
  405b2c:	0f b7 54 06 fe       	movzwl -0x2(%rsi,%rax,1),%edx
  405b31:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  405b36:	66 89 54 07 fe       	mov    %dx,-0x2(%rdi,%rax,1)
  405b3b:	48 8b 8c 24 a8 00 00 	mov    0xa8(%rsp),%rcx
  405b42:	00 
  405b43:	48 8b 94 24 a0 00 00 	mov    0xa0(%rsp),%rdx
  405b4a:	00 
  405b4b:	e9 4c ff ff ff       	jmpq   405a9c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x76c>
  405b50:	48 8b 54 06 f8       	mov    -0x8(%rsi,%rax,1),%rdx
  405b55:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  405b5a:	48 89 54 07 f8       	mov    %rdx,-0x8(%rdi,%rax,1)
  405b5f:	48 83 e8 01          	sub    $0x1,%rax
  405b63:	48 c1 e8 03          	shr    $0x3,%rax
  405b67:	48 89 c1             	mov    %rax,%rcx
  405b6a:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405b6d:	48 8b 94 24 a0 00 00 	mov    0xa0(%rsp),%rdx
  405b74:	00 
  405b75:	48 8b 44 24 58       	mov    0x58(%rsp),%rax
  405b7a:	48 8b 7c 24 68       	mov    0x68(%rsp),%rdi
  405b7f:	48 89 c6             	mov    %rax,%rsi
  405b82:	48 89 04 fa          	mov    %rax,(%rdx,%rdi,8)
  405b86:	e9 6f fb ff ff       	jmpq   4056fa <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x3ca>
            my_copy_stack(empty_stack_idx);
  405b8b:	0b 44 24 4c          	or     0x4c(%rsp),%eax
  405b8f:	48 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%rcx
  405b96:	00 
  405b97:	89 42 14             	mov    %eax,0x14(%rdx)
  405b9a:	48 63 54 24 48       	movslq 0x48(%rsp),%rdx
  405b9f:	48 8b 34 d1          	mov    (%rcx,%rdx,8),%rsi
  405ba3:	0f be 06             	movsbl (%rsi),%eax
  405ba6:	83 c0 01             	add    $0x1,%eax
  405ba9:	48 98                	cltq   
  405bab:	48 83 f8 08          	cmp    $0x8,%rax
  405baf:	0f 83 78 03 00 00    	jae    405f2d <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xbfd>
  405bb5:	a8 04                	test   $0x4,%al
  405bb7:	0f 85 6f 04 00 00    	jne    40602c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xcfc>
  405bbd:	48 85 c0             	test   %rax,%rax
  405bc0:	74 1a                	je     405bdc <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x8ac>
  405bc2:	0f b6 0e             	movzbl (%rsi),%ecx
  405bc5:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  405bca:	88 0f                	mov    %cl,(%rdi)
  405bcc:	48 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%rcx
  405bd3:	00 
  405bd4:	a8 02                	test   $0x2,%al
  405bd6:	0f 85 6e 04 00 00    	jne    40604a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xd1a>
  405bdc:	48 8b 44 24 58       	mov    0x58(%rsp),%rax
  405be1:	48 89 04 d1          	mov    %rax,(%rcx,%rdx,8)
  405be5:	48 89 c1             	mov    %rax,%rcx
  405be8:	e9 06 fd ff ff       	jmpq   4058f3 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x5c3>
            while ((*col_num_cards) == 0)
  405bed:	44 89 f1             	mov    %r14d,%ecx
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  405bf0:	4c 63 74 24 04       	movslq 0x4(%rsp),%r14
        int dest_fc_idx = 0;
  405bf5:	31 f6                	xor    %esi,%esi
            while ((*col_num_cards) == 0)
  405bf7:	45 31 d2             	xor    %r10d,%r10d
  405bfa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405c00:	48 63 fe             	movslq %esi,%rdi
  405c03:	41 80 7c 39 40 00    	cmpb   $0x0,0x40(%r9,%rdi,1)
  405c09:	0f 84 3d 02 00 00    	je     405e4c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb1c>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  405c0f:	8d 46 01             	lea    0x1(%rsi),%eax
  405c12:	83 f8 04             	cmp    $0x4,%eax
  405c15:	74 35                	je     405c4c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x91c>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405c17:	48 63 f8             	movslq %eax,%rdi
  405c1a:	41 80 7c 39 40 00    	cmpb   $0x0,0x40(%r9,%rdi,1)
  405c20:	0f 84 24 02 00 00    	je     405e4a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb1a>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  405c26:	8d 46 02             	lea    0x2(%rsi),%eax
  405c29:	83 f8 04             	cmp    $0x4,%eax
  405c2c:	74 1e                	je     405c4c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x91c>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405c2e:	48 63 f8             	movslq %eax,%rdi
  405c31:	41 80 7c 39 40 00    	cmpb   $0x0,0x40(%r9,%rdi,1)
  405c37:	0f 84 0d 02 00 00    	je     405e4a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb1a>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  405c3d:	85 f6                	test   %esi,%esi
  405c3f:	75 0b                	jne    405c4c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x91c>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405c41:	41 80 79 43 00       	cmpb   $0x0,0x43(%r9)
  405c46:	0f 84 60 02 00 00    	je     405eac <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb7c>
  405c4c:	45 84 d2             	test   %r10b,%r10b
  405c4f:	74 07                	je     405c58 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x928>
  405c51:	89 8c 24 b0 00 00 00 	mov    %ecx,0xb0(%rsp)
    while ((*col_num_cards) == 0)
  405c58:	85 d2                	test   %edx,%edx
  405c5a:	0f 84 10 fb ff ff    	je     405770 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x440>
  405c60:	48 63 44 24 04       	movslq 0x4(%rsp),%rax
    int put_cards_in_col_idx = 0;
  405c65:	45 31 f6             	xor    %r14d,%r14d
  405c68:	48 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%rcx
  405c6f:	00 
  405c70:	48 89 44 24 60       	mov    %rax,0x60(%rsp)
    char *const indirect_stacks_buffer =
  405c75:	48 8b 84 24 80 00 00 	mov    0x80(%rsp),%rax
  405c7c:	00 
  405c7d:	48 05 00 01 00 00    	add    $0x100,%rax
  405c83:	48 89 84 24 88 00 00 	mov    %rax,0x88(%rsp)
  405c8a:	00 
  405c8b:	eb 55                	jmp    405ce2 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x9b2>
  405c8d:	0f 1f 00             	nopl   (%rax)
  405c90:	48 8b 7c 24 60       	mov    0x60(%rsp),%rdi
  405c95:	49 8b 34 f9          	mov    (%r9,%rdi,8),%rsi
    fcs_col_pop_card(col, ret);
  405c99:	0f be 3e             	movsbl (%rsi),%edi
  405c9c:	89 f9                	mov    %edi,%ecx
  405c9e:	83 ef 01             	sub    $0x1,%edi
  405ca1:	83 e9 01             	sub    $0x1,%ecx
  405ca4:	48 63 ff             	movslq %edi,%rdi
        --(*col_num_cards);
  405ca7:	83 ea 01             	sub    $0x1,%edx
  405caa:	0f b6 7c 3e 01       	movzbl 0x1(%rsi,%rdi,1),%edi
  405caf:	88 0e                	mov    %cl,(%rsi)
  405cb1:	48 0f be c9          	movsbq %cl,%rcx
  405cb5:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  405cba:	49 8b 0c c1          	mov    (%r9,%rax,8),%rcx
    fcs_col_push_card(col, card);
  405cbe:	48 0f be 01          	movsbq (%rcx),%rax
  405cc2:	8d 70 01             	lea    0x1(%rax),%esi
  405cc5:	40 88 31             	mov    %sil,(%rcx)
  405cc8:	40 88 7c 01 01       	mov    %dil,0x1(%rcx,%rax,1)
  405ccd:	48 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%rcx
  405cd4:	00 
  405cd5:	89 94 24 b0 00 00 00 	mov    %edx,0xb0(%rsp)
        while ((*col_num_cards) == 0)
  405cdc:	0f 84 96 fa ff ff    	je     405778 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x448>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405ce2:	41 83 fe 08          	cmp    $0x8,%r14d
  405ce6:	0f 84 d9 01 00 00    	je     405ec5 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb95>
        if (fcs_state_col_is_empty(state, ret))
  405cec:	49 63 c6             	movslq %r14d,%rax
  405cef:	48 8b 04 c1          	mov    (%rcx,%rax,8),%rax
  405cf3:	80 38 00             	cmpb   $0x0,(%rax)
  405cf6:	0f 84 ca 02 00 00    	je     405fc6 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc96>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405cfc:	41 8d 7e 01          	lea    0x1(%r14),%edi
  405d00:	83 ff 08             	cmp    $0x8,%edi
  405d03:	0f 84 bc 01 00 00    	je     405ec5 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb95>
        if (fcs_state_col_is_empty(state, ret))
  405d09:	48 63 c7             	movslq %edi,%rax
  405d0c:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  405d10:	80 3e 00             	cmpb   $0x0,(%rsi)
  405d13:	0f 84 8a 01 00 00    	je     405ea3 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb73>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405d19:	41 8d 7e 02          	lea    0x2(%r14),%edi
  405d1d:	83 ff 08             	cmp    $0x8,%edi
  405d20:	0f 84 9f 01 00 00    	je     405ec5 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb95>
        if (fcs_state_col_is_empty(state, ret))
  405d26:	48 63 c7             	movslq %edi,%rax
  405d29:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  405d2d:	80 3e 00             	cmpb   $0x0,(%rsi)
  405d30:	0f 84 6d 01 00 00    	je     405ea3 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb73>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405d36:	41 8d 7e 03          	lea    0x3(%r14),%edi
  405d3a:	83 ff 08             	cmp    $0x8,%edi
  405d3d:	0f 84 82 01 00 00    	je     405ec5 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb95>
        if (fcs_state_col_is_empty(state, ret))
  405d43:	48 63 c7             	movslq %edi,%rax
  405d46:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  405d4a:	80 3e 00             	cmpb   $0x0,(%rsi)
  405d4d:	0f 84 50 01 00 00    	je     405ea3 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb73>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405d53:	41 8d 7e 04          	lea    0x4(%r14),%edi
  405d57:	83 ff 08             	cmp    $0x8,%edi
  405d5a:	0f 84 65 01 00 00    	je     405ec5 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb95>
        if (fcs_state_col_is_empty(state, ret))
  405d60:	48 63 c7             	movslq %edi,%rax
  405d63:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  405d67:	80 3e 00             	cmpb   $0x0,(%rsi)
  405d6a:	0f 84 33 01 00 00    	je     405ea3 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb73>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405d70:	41 8d 7e 05          	lea    0x5(%r14),%edi
  405d74:	83 ff 08             	cmp    $0x8,%edi
  405d77:	0f 84 48 01 00 00    	je     405ec5 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb95>
        if (fcs_state_col_is_empty(state, ret))
  405d7d:	48 63 c7             	movslq %edi,%rax
  405d80:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  405d84:	80 3e 00             	cmpb   $0x0,(%rsi)
  405d87:	0f 84 16 01 00 00    	je     405ea3 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb73>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405d8d:	41 8d 7e 06          	lea    0x6(%r14),%edi
  405d91:	83 ff 08             	cmp    $0x8,%edi
  405d94:	0f 84 2b 01 00 00    	je     405ec5 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb95>
        if (fcs_state_col_is_empty(state, ret))
  405d9a:	48 63 c7             	movslq %edi,%rax
  405d9d:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  405da1:	80 3e 00             	cmpb   $0x0,(%rsi)
  405da4:	0f 84 f9 00 00 00    	je     405ea3 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb73>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405daa:	45 85 f6             	test   %r14d,%r14d
  405dad:	0f 85 12 01 00 00    	jne    405ec5 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb95>
        if (fcs_state_col_is_empty(state, ret))
  405db3:	48 8b 49 38          	mov    0x38(%rcx),%rcx
    return -1;
  405db7:	bf ff ff ff ff       	mov    $0xffffffff,%edi
  405dbc:	48 c7 c0 ff ff ff ff 	mov    $0xffffffffffffffff,%rax
        if (fcs_state_col_is_empty(state, ret))
  405dc3:	80 39 00             	cmpb   $0x0,(%rcx)
  405dc6:	0f 84 cd 00 00 00    	je     405e99 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb69>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  405dcc:	48 8b b4 24 a8 00 00 	mov    0xa8(%rsp),%rsi
  405dd3:	00 
  405dd4:	8b 4e 14             	mov    0x14(%rsi),%ecx
  405dd7:	0f a3 f9             	bt     %edi,%ecx
  405dda:	0f 82 b0 fe ff ff    	jb     405c90 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x960>
  405de0:	0f ab f9             	bts    %edi,%ecx
  405de3:	c1 e7 07             	shl    $0x7,%edi
  405de6:	89 4e 14             	mov    %ecx,0x14(%rsi)
  405de9:	49 8d 34 c1          	lea    (%r9,%rax,8),%rsi
  405ded:	4c 63 d7             	movslq %edi,%r10
  405df0:	4c 03 94 24 88 00 00 	add    0x88(%rsp),%r10
  405df7:	00 
  405df8:	48 89 b4 24 80 00 00 	mov    %rsi,0x80(%rsp)
  405dff:	00 
  405e00:	48 8b 36             	mov    (%rsi),%rsi
  405e03:	0f be 0e             	movsbl (%rsi),%ecx
  405e06:	83 c1 01             	add    $0x1,%ecx
  405e09:	48 63 c9             	movslq %ecx,%rcx
  405e0c:	48 83 f9 08          	cmp    $0x8,%rcx
  405e10:	0f 83 fa 00 00 00    	jae    405f10 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xbe0>
  405e16:	f6 c1 04             	test   $0x4,%cl
  405e19:	0f 85 b6 01 00 00    	jne    405fd5 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xca5>
  405e1f:	48 85 c9             	test   %rcx,%rcx
  405e22:	74 16                	je     405e3a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb0a>
  405e24:	0f b6 3e             	movzbl (%rsi),%edi
  405e27:	41 88 3a             	mov    %dil,(%r10)
  405e2a:	f6 c1 02             	test   $0x2,%cl
  405e2d:	74 0b                	je     405e3a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb0a>
  405e2f:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  405e34:	66 41 89 74 0a fe    	mov    %si,-0x2(%r10,%rcx,1)
  405e3a:	48 8b bc 24 80 00 00 	mov    0x80(%rsp),%rdi
  405e41:	00 
  405e42:	4c 89 17             	mov    %r10,(%rdi)
  405e45:	e9 46 fe ff ff       	jmpq   405c90 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x960>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405e4a:	89 c6                	mov    %eax,%esi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  405e4c:	4b 8b 0c f1          	mov    (%r9,%r14,8),%rcx
            ++dest_fc_idx;
  405e50:	83 c6 01             	add    $0x1,%esi
    fcs_col_pop_card(col, ret);
  405e53:	44 0f be 11          	movsbl (%rcx),%r10d
  405e57:	44 89 d0             	mov    %r10d,%eax
  405e5a:	41 83 ea 01          	sub    $0x1,%r10d
  405e5e:	4d 63 d2             	movslq %r10d,%r10
  405e61:	83 e8 01             	sub    $0x1,%eax
  405e64:	46 0f b6 54 11 01    	movzbl 0x1(%rcx,%r10,1),%r10d
  405e6a:	88 01                	mov    %al,(%rcx)
  405e6c:	48 0f be c0          	movsbq %al,%rax
  405e70:	c6 44 01 01 00       	movb   $0x0,0x1(%rcx,%rax,1)
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  405e75:	45 88 54 39 40       	mov    %r10b,0x40(%r9,%rdi,1)
            while ((*col_num_cards) == 0)
  405e7a:	83 ea 01             	sub    $0x1,%edx
  405e7d:	0f 84 ed f8 ff ff    	je     405770 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x440>
  405e83:	41 ba 01 00 00 00    	mov    $0x1,%r10d
  405e89:	89 d1                	mov    %edx,%ecx
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  405e8b:	83 fe 04             	cmp    $0x4,%esi
  405e8e:	0f 85 6c fd ff ff    	jne    405c00 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x8d0>
  405e94:	e9 b8 fd ff ff       	jmpq   405c51 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x921>
        if (fcs_state_col_is_empty(state, ret))
  405e99:	bf 07 00 00 00       	mov    $0x7,%edi
  405e9e:	b8 07 00 00 00       	mov    $0x7,%eax
  405ea3:	44 8d 77 01          	lea    0x1(%rdi),%r14d
  405ea7:	e9 20 ff ff ff       	jmpq   405dcc <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa9c>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405eac:	be 03 00 00 00       	mov    $0x3,%esi
  405eb1:	bf 03 00 00 00       	mov    $0x3,%edi
  405eb6:	eb 94                	jmp    405e4c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb1c>
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  405eb8:	48 8b ac 24 a0 00 00 	mov    0xa0(%rsp),%rbp
  405ebf:	00 
  405ec0:	e9 d2 fa ff ff       	jmpq   405997 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x667>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405ec5:	45 31 f6             	xor    %r14d,%r14d
    return -1;
  405ec8:	bf ff ff ff ff       	mov    $0xffffffff,%edi
  405ecd:	48 c7 c0 ff ff ff ff 	mov    $0xffffffffffffffff,%rax
  405ed4:	e9 f3 fe ff ff       	jmpq   405dcc <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa9c>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  405ed9:	48 83 c1 10          	add    $0x10,%rcx
  405edd:	48 89 c7             	mov    %rax,%rdi
  405ee0:	48 89 ce             	mov    %rcx,%rsi
  405ee3:	48 c1 e6 04          	shl    $0x4,%rsi
  405ee7:	e8 84 b2 ff ff       	callq  401170 <realloc@plt>
        list->states =
  405eec:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  405ef1:	48 89 47 08          	mov    %rax,0x8(%rdi)
  405ef5:	48 8b 17             	mov    (%rdi),%rdx
  405ef8:	e9 ba fa ff ff       	jmpq   4059b7 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x687>
  405efd:	48 8b 85 f0 00 00 00 	mov    0xf0(%rbp),%rax
  405f04:	48 89 85 e8 00 00 00 	mov    %rax,0xe8(%rbp)
  405f0b:	e9 7f fa ff ff       	jmpq   40598f <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x65f>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  405f10:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  405f15:	49 89 7c 0a f8       	mov    %rdi,-0x8(%r10,%rcx,1)
  405f1a:	48 83 e9 01          	sub    $0x1,%rcx
  405f1e:	4c 89 d7             	mov    %r10,%rdi
  405f21:	48 c1 e9 03          	shr    $0x3,%rcx
  405f25:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405f28:	e9 0d ff ff ff       	jmpq   405e3a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb0a>
            my_copy_stack(empty_stack_idx);
  405f2d:	48 8b 4c 06 f8       	mov    -0x8(%rsi,%rax,1),%rcx
  405f32:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  405f37:	48 89 4c 07 f8       	mov    %rcx,-0x8(%rdi,%rax,1)
  405f3c:	48 83 e8 01          	sub    $0x1,%rax
  405f40:	48 c1 e8 03          	shr    $0x3,%rax
  405f44:	48 89 c1             	mov    %rax,%rcx
  405f47:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405f4a:	48 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%rcx
  405f51:	00 
  405f52:	e9 85 fc ff ff       	jmpq   405bdc <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x8ac>
    SET_empty_stack_idx(empty_stack_idx);
  405f57:	c7 44 24 48 04 00 00 	movl   $0x4,0x48(%rsp)
  405f5e:	00 
  405f5f:	8b 4c 24 48          	mov    0x48(%rsp),%ecx
  405f63:	41 ba 01 00 00 00    	mov    $0x1,%r10d
  405f69:	41 89 c8             	mov    %ecx,%r8d
  405f6c:	41 d3 e2             	shl    %cl,%r10d
  405f6f:	41 c1 e0 07          	shl    $0x7,%r8d
  405f73:	44 89 54 24 4c       	mov    %r10d,0x4c(%rsp)
  405f78:	4d 63 c0             	movslq %r8d,%r8
  405f7b:	e9 50 f4 ff ff       	jmpq   4053d0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa0>
  405f80:	c7 44 24 48 02 00 00 	movl   $0x2,0x48(%rsp)
  405f87:	00 
  405f88:	eb d5                	jmp    405f5f <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc2f>
  405f8a:	c7 44 24 48 00 00 00 	movl   $0x0,0x48(%rsp)
  405f91:	00 
  405f92:	eb cb                	jmp    405f5f <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc2f>
  405f94:	c7 44 24 48 01 00 00 	movl   $0x1,0x48(%rsp)
  405f9b:	00 
  405f9c:	eb c1                	jmp    405f5f <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc2f>
  405f9e:	c7 44 24 48 03 00 00 	movl   $0x3,0x48(%rsp)
  405fa5:	00 
  405fa6:	eb b7                	jmp    405f5f <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc2f>
  405fa8:	c7 44 24 48 05 00 00 	movl   $0x5,0x48(%rsp)
  405faf:	00 
  405fb0:	eb ad                	jmp    405f5f <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc2f>
  405fb2:	c7 44 24 48 06 00 00 	movl   $0x6,0x48(%rsp)
  405fb9:	00 
  405fba:	eb a3                	jmp    405f5f <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc2f>
  405fbc:	c7 44 24 48 07 00 00 	movl   $0x7,0x48(%rsp)
  405fc3:	00 
  405fc4:	eb 99                	jmp    405f5f <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc2f>
        if (fcs_state_col_is_empty(state, ret))
  405fc6:	49 63 c6             	movslq %r14d,%rax
  405fc9:	41 83 c6 01          	add    $0x1,%r14d
  405fcd:	48 89 c7             	mov    %rax,%rdi
  405fd0:	e9 f7 fd ff ff       	jmpq   405dcc <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa9c>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  405fd5:	8b 3e                	mov    (%rsi),%edi
  405fd7:	41 89 3a             	mov    %edi,(%r10)
  405fda:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  405fde:	41 89 74 0a fc       	mov    %esi,-0x4(%r10,%rcx,1)
  405fe3:	e9 52 fe ff ff       	jmpq   405e3a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb0a>
                copy_two_stacks(stack_idx, empty_stack_idx);
  405fe8:	8b 16                	mov    (%rsi),%edx
  405fea:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  405fef:	89 17                	mov    %edx,(%rdi)
  405ff1:	8b 54 06 fc          	mov    -0x4(%rsi,%rax,1),%edx
  405ff5:	89 54 07 fc          	mov    %edx,-0x4(%rdi,%rax,1)
  405ff9:	48 8b 8c 24 a8 00 00 	mov    0xa8(%rsp),%rcx
  406000:	00 
  406001:	48 8b 94 24 a0 00 00 	mov    0xa0(%rsp),%rdx
  406008:	00 
  406009:	e9 8e fa ff ff       	jmpq   405a9c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x76c>
  40600e:	8b 16                	mov    (%rsi),%edx
  406010:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  406015:	89 17                	mov    %edx,(%rdi)
  406017:	8b 54 06 fc          	mov    -0x4(%rsi,%rax,1),%edx
  40601b:	89 54 07 fc          	mov    %edx,-0x4(%rdi,%rax,1)
  40601f:	48 8b 94 24 a0 00 00 	mov    0xa0(%rsp),%rdx
  406026:	00 
  406027:	e9 49 fb ff ff       	jmpq   405b75 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x845>
            my_copy_stack(empty_stack_idx);
  40602c:	8b 0e                	mov    (%rsi),%ecx
  40602e:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  406033:	89 0f                	mov    %ecx,(%rdi)
  406035:	8b 4c 06 fc          	mov    -0x4(%rsi,%rax,1),%ecx
  406039:	89 4c 07 fc          	mov    %ecx,-0x4(%rdi,%rax,1)
  40603d:	48 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%rcx
  406044:	00 
  406045:	e9 92 fb ff ff       	jmpq   405bdc <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x8ac>
  40604a:	0f b7 4c 06 fe       	movzwl -0x2(%rsi,%rax,1),%ecx
  40604f:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  406054:	66 89 4c 07 fe       	mov    %cx,-0x2(%rdi,%rax,1)
  406059:	48 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%rcx
  406060:	00 
  406061:	e9 76 fb ff ff       	jmpq   405bdc <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x8ac>
  406066:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40606d:	00 00 00 

0000000000406070 <fc_solve_sfs_move_freecell_cards_to_empty_stack>:
    if (!soft_thread->num_vacant_stacks)
  406070:	80 bf e3 01 00 00 00 	cmpb   $0x0,0x1e3(%rdi)
  406077:	0f 84 73 02 00 00    	je     4062f0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x280>
{
  40607d:	41 57                	push   %r15
  40607f:	41 56                	push   %r14
  406081:	41 55                	push   %r13
  406083:	41 54                	push   %r12
  406085:	55                   	push   %rbp
  406086:	48 89 cd             	mov    %rcx,%rbp
  406089:	53                   	push   %rbx
  40608a:	48 83 ec 58          	sub    $0x58,%rsp
    SET_empty_stack_idx(empty_stack_idx);
  40608e:	48 8b 06             	mov    (%rsi),%rax
  406091:	80 38 00             	cmpb   $0x0,(%rax)
  406094:	0f 84 f8 02 00 00    	je     406392 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x322>
  40609a:	48 8b 46 08          	mov    0x8(%rsi),%rax
  40609e:	80 38 00             	cmpb   $0x0,(%rax)
  4060a1:	0f 84 ef 02 00 00    	je     406396 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x326>
  4060a7:	48 8b 46 10          	mov    0x10(%rsi),%rax
  4060ab:	80 38 00             	cmpb   $0x0,(%rax)
  4060ae:	0f 84 e9 02 00 00    	je     40639d <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x32d>
  4060b4:	48 8b 46 18          	mov    0x18(%rsi),%rax
  4060b8:	80 38 00             	cmpb   $0x0,(%rax)
  4060bb:	0f 84 e3 02 00 00    	je     4063a4 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x334>
  4060c1:	48 8b 46 20          	mov    0x20(%rsi),%rax
  4060c5:	80 38 00             	cmpb   $0x0,(%rax)
  4060c8:	0f 84 86 02 00 00    	je     406354 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2e4>
  4060ce:	48 8b 46 28          	mov    0x28(%rsi),%rax
  4060d2:	80 38 00             	cmpb   $0x0,(%rax)
  4060d5:	0f 84 d0 02 00 00    	je     4063ab <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x33b>
  4060db:	48 8b 46 30          	mov    0x30(%rsi),%rax
  4060df:	80 38 00             	cmpb   $0x0,(%rax)
  4060e2:	0f 84 ca 02 00 00    	je     4063b2 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x342>
  4060e8:	4c 8b 46 38          	mov    0x38(%rsi),%r8
  4060ec:	b8 00 04 00 00       	mov    $0x400,%eax
  4060f1:	b9 08 00 00 00       	mov    $0x8,%ecx
  4060f6:	c7 44 24 0c 00 01 00 	movl   $0x100,0xc(%rsp)
  4060fd:	00 
  4060fe:	41 80 38 00          	cmpb   $0x0,(%r8)
  406102:	0f 84 b1 02 00 00    	je     4063b9 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x349>
  406108:	49 89 fc             	mov    %rdi,%r12
    tests_define_accessors();
  40610b:	48 8b 3f             	mov    (%rdi),%rdi
  40610e:	48 89 54 24 18       	mov    %rdx,0x18(%rsp)
  406113:	48 89 f3             	mov    %rsi,%rbx
        my_copy_stack(empty_stack_idx);
  406116:	45 31 ff             	xor    %r15d,%r15d
  406119:	48 8d 84 07 00 01 00 	lea    0x100(%rdi,%rax,1),%rax
  406120:	00 
    tests_define_accessors();
  406121:	48 89 7c 24 10       	mov    %rdi,0x10(%rsp)
        my_copy_stack(empty_stack_idx);
  406126:	48 89 44 24 20       	mov    %rax,0x20(%rsp)
  40612b:	48 63 c1             	movslq %ecx,%rax
  40612e:	48 89 04 24          	mov    %rax,(%rsp)
        const fcs_card card = fcs_freecell_card(state, fc);
  406132:	46 0f b6 6c 3b 40    	movzbl 0x40(%rbx,%r15,1),%r13d
  406138:	45 89 fe             	mov    %r15d,%r14d
        if (SHOULD_SKIP_FC_CARD(card))
  40613b:	45 84 ed             	test   %r13b,%r13b
  40613e:	0f 84 d6 00 00 00    	je     40621a <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x1aa>
        sfs_check_state_begin();
  406144:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
  406149:	48 8d 74 24 30       	lea    0x30(%rsp),%rsi
  40614e:	48 89 da             	mov    %rbx,%rdx
  406151:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  406156:	e8 c5 b8 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
        my_copy_stack(empty_stack_idx);
  40615b:	48 8b 54 24 38       	mov    0x38(%rsp),%rdx
  406160:	8b 42 14             	mov    0x14(%rdx),%eax
  406163:	85 44 24 0c          	test   %eax,0xc(%rsp)
  406167:	0f 84 e3 00 00 00    	je     406250 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x1e0>
  40616d:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  406172:	48 8b 0c 24          	mov    (%rsp),%rcx
  406176:	48 8b 14 c8          	mov    (%rax,%rcx,8),%rdx
    fcs_col_push_card(col, card);
  40617a:	48 0f be 02          	movsbq (%rdx),%rax
    if (!fc_solve_check_and_add_state(
  40617e:	48 8d 74 24 30       	lea    0x30(%rsp),%rsi
        fcs_empty_freecell(new_state_key, fc);
  406183:	4d 63 ce             	movslq %r14d,%r9
  406186:	8d 48 01             	lea    0x1(%rax),%ecx
  406189:	88 0a                	mov    %cl,(%rdx)
  40618b:	44 88 6c 02 01       	mov    %r13b,0x1(%rdx,%rax,1)
  406190:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  406195:	48 8d 54 24 40       	lea    0x40(%rsp),%rdx
  40619a:	42 c6 44 08 40 00    	movb   $0x0,0x40(%rax,%r9,1)
    const_SLOT(hard_thread, soft_thread);
  4061a0:	4d 8b 34 24          	mov    (%r12),%r14
    if (!fc_solve_check_and_add_state(
  4061a4:	4c 89 f7             	mov    %r14,%rdi
  4061a7:	e8 c4 b9 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  4061ac:	84 c0                	test   %al,%al
  4061ae:	0f 85 8c 00 00 00    	jne    406240 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x1d0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  4061b4:	41 80 be 18 05 00 00 	cmpb   $0x0,0x518(%r14)
  4061bb:	00 
  4061bc:	0f 84 3e 01 00 00    	je     406300 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x290>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  4061c2:	49 8b 96 b0 00 00 00 	mov    0xb0(%r14),%rdx
  4061c9:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  4061ce:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  4061d1:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  4061d6:	49 89 86 b0 00 00 00 	mov    %rax,0xb0(%r14)
        return FCS_STATE_kv_to_collectible(&existing_state);
  4061dd:	48 8b 54 24 40       	mov    0x40(%rsp),%rdx
    if ((!((list->num_states + (list->states != NULL)) &
  4061e2:	48 8b 45 08          	mov    0x8(%rbp),%rax
  4061e6:	31 f6                	xor    %esi,%esi
  4061e8:	48 8b 7d 00          	mov    0x0(%rbp),%rdi
  4061ec:	48 85 c0             	test   %rax,%rax
  4061ef:	40 0f 95 c6          	setne  %sil
  4061f3:	48 01 fe             	add    %rdi,%rsi
  4061f6:	40 f6 c6 0f          	test   $0xf,%sil
  4061fa:	0f 84 c0 00 00 00    	je     4062c0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x250>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  406200:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
  406204:	48 c1 e7 04          	shl    $0x4,%rdi
  406208:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  40620c:	48 01 f8             	add    %rdi,%rax
  40620f:	48 89 4d 00          	mov    %rcx,0x0(%rbp)
  406213:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  406217:	48 89 10             	mov    %rdx,(%rax)
  40621a:	49 83 c7 01          	add    $0x1,%r15
    for (int fc = 0; fc < LOCAL_FREECELLS_NUM; fc++)
  40621e:	49 83 ff 04          	cmp    $0x4,%r15
  406222:	0f 85 0a ff ff ff    	jne    406132 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0xc2>
}
  406228:	48 83 c4 58          	add    $0x58,%rsp
  40622c:	5b                   	pop    %rbx
  40622d:	5d                   	pop    %rbp
  40622e:	41 5c                	pop    %r12
  406230:	41 5d                	pop    %r13
  406232:	41 5e                	pop    %r14
  406234:	41 5f                	pop    %r15
  406236:	c3                   	retq   
  406237:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40623e:	00 00 
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  406240:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  406245:	eb 9b                	jmp    4061e2 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x172>
  406247:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40624e:	00 00 
        my_copy_stack(empty_stack_idx);
  406250:	0b 44 24 0c          	or     0xc(%rsp),%eax
  406254:	89 42 14             	mov    %eax,0x14(%rdx)
  406257:	48 8b 04 24          	mov    (%rsp),%rax
  40625b:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  406260:	48 8b 34 c2          	mov    (%rdx,%rax,8),%rsi
  406264:	0f be 06             	movsbl (%rsi),%eax
  406267:	83 c0 01             	add    $0x1,%eax
  40626a:	48 98                	cltq   
  40626c:	48 83 f8 08          	cmp    $0x8,%rax
  406270:	0f 83 aa 00 00 00    	jae    406320 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2b0>
  406276:	a8 04                	test   $0x4,%al
  406278:	0f 85 fc 00 00 00    	jne    40637a <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x30a>
  40627e:	48 85 c0             	test   %rax,%rax
  406281:	0f 84 b8 00 00 00    	je     40633f <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2cf>
  406287:	0f b6 16             	movzbl (%rsi),%edx
  40628a:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  40628f:	88 11                	mov    %dl,(%rcx)
  406291:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  406296:	a8 02                	test   $0x2,%al
  406298:	0f 84 a1 00 00 00    	je     40633f <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2cf>
  40629e:	0f b7 54 06 fe       	movzwl -0x2(%rsi,%rax,1),%edx
  4062a3:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  4062a8:	66 89 54 01 fe       	mov    %dx,-0x2(%rcx,%rax,1)
  4062ad:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  4062b2:	e9 88 00 00 00       	jmpq   40633f <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2cf>
  4062b7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4062be:	00 00 
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  4062c0:	48 83 c6 10          	add    $0x10,%rsi
  4062c4:	48 89 c7             	mov    %rax,%rdi
  4062c7:	48 89 54 24 28       	mov    %rdx,0x28(%rsp)
  4062cc:	48 c1 e6 04          	shl    $0x4,%rsi
  4062d0:	e8 9b ae ff ff       	callq  401170 <realloc@plt>
  4062d5:	48 8b 7d 00          	mov    0x0(%rbp),%rdi
        list->states =
  4062d9:	48 89 45 08          	mov    %rax,0x8(%rbp)
  4062dd:	48 8b 54 24 28       	mov    0x28(%rsp),%rdx
  4062e2:	e9 19 ff ff ff       	jmpq   406200 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x190>
  4062e7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4062ee:	00 00 
  4062f0:	c3                   	retq   
  4062f1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4062f8:	00 00 00 00 
  4062fc:	0f 1f 40 00          	nopl   0x0(%rax)
  406300:	49 8b 86 f0 00 00 00 	mov    0xf0(%r14),%rax
  406307:	49 89 86 e8 00 00 00 	mov    %rax,0xe8(%r14)
  40630e:	e9 ca fe ff ff       	jmpq   4061dd <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x16d>
  406313:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40631a:	00 00 00 00 
  40631e:	66 90                	xchg   %ax,%ax
  406320:	48 8b 54 06 f8       	mov    -0x8(%rsi,%rax,1),%rdx
  406325:	48 8d 48 ff          	lea    -0x1(%rax),%rcx
  406329:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  40632e:	48 c1 e9 03          	shr    $0x3,%rcx
  406332:	48 89 54 07 f8       	mov    %rdx,-0x8(%rdi,%rax,1)
  406337:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40633a:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  40633f:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  406344:	48 8b 0c 24          	mov    (%rsp),%rcx
  406348:	48 89 04 ca          	mov    %rax,(%rdx,%rcx,8)
  40634c:	48 89 c2             	mov    %rax,%rdx
  40634f:	e9 26 fe ff ff       	jmpq   40617a <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x10a>
    SET_empty_stack_idx(empty_stack_idx);
  406354:	b9 04 00 00 00       	mov    $0x4,%ecx
  406359:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  406360:	89 c8                	mov    %ecx,%eax
  406362:	41 b8 01 00 00 00    	mov    $0x1,%r8d
  406368:	c1 e0 07             	shl    $0x7,%eax
  40636b:	41 d3 e0             	shl    %cl,%r8d
  40636e:	48 98                	cltq   
  406370:	44 89 44 24 0c       	mov    %r8d,0xc(%rsp)
  406375:	e9 8e fd ff ff       	jmpq   406108 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x98>
        my_copy_stack(empty_stack_idx);
  40637a:	8b 16                	mov    (%rsi),%edx
  40637c:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  406381:	89 11                	mov    %edx,(%rcx)
  406383:	8b 54 06 fc          	mov    -0x4(%rsi,%rax,1),%edx
  406387:	89 54 01 fc          	mov    %edx,-0x4(%rcx,%rax,1)
  40638b:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  406390:	eb ad                	jmp    40633f <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2cf>
    SET_empty_stack_idx(empty_stack_idx);
  406392:	31 c9                	xor    %ecx,%ecx
  406394:	eb ca                	jmp    406360 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2f0>
  406396:	b9 01 00 00 00       	mov    $0x1,%ecx
  40639b:	eb c3                	jmp    406360 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2f0>
  40639d:	b9 02 00 00 00       	mov    $0x2,%ecx
  4063a2:	eb bc                	jmp    406360 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2f0>
  4063a4:	b9 03 00 00 00       	mov    $0x3,%ecx
  4063a9:	eb b5                	jmp    406360 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2f0>
  4063ab:	b9 05 00 00 00       	mov    $0x5,%ecx
  4063b0:	eb ae                	jmp    406360 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2f0>
  4063b2:	b9 06 00 00 00       	mov    $0x6,%ecx
  4063b7:	eb a7                	jmp    406360 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2f0>
  4063b9:	b9 07 00 00 00       	mov    $0x7,%ecx
  4063be:	eb a0                	jmp    406360 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2f0>

00000000004063c0 <fc_solve_sfs_move_sequences_to_free_stacks>:
    const fcs_game_limit num_vacant_stacks = soft_thread->num_vacant_stacks;
  4063c0:	0f b6 87 e3 01 00 00 	movzbl 0x1e3(%rdi),%eax
    if (num_vacant_stacks == 0)
  4063c7:	84 c0                	test   %al,%al
  4063c9:	0f 84 67 0d 00 00    	je     407136 <fc_solve_sfs_move_sequences_to_free_stacks+0xd76>
{
  4063cf:	41 57                	push   %r15
  4063d1:	49 89 c8             	mov    %rcx,%r8
  4063d4:	41 56                	push   %r14
  4063d6:	41 55                	push   %r13
  4063d8:	41 54                	push   %r12
  4063da:	55                   	push   %rbp
  4063db:	53                   	push   %rbx
        calc_max_sequence_move(num_vacant_freecells, num_vacant_stacks - 1);
  4063dc:	89 c3                	mov    %eax,%ebx
  4063de:	8d 4b ff             	lea    -0x1(%rbx),%ecx
{
  4063e1:	48 81 ec b8 00 00 00 	sub    $0xb8,%rsp
        calc_max_sequence_move(num_vacant_freecells, num_vacant_stacks - 1);
  4063e8:	44 0f b6 af e4 01 00 	movzbl 0x1e4(%rdi),%r13d
  4063ef:	00 
  4063f0:	89 44 24 04          	mov    %eax,0x4(%rsp)
  4063f4:	41 8d 45 01          	lea    0x1(%r13),%eax
    const int max_sequence_len =
  4063f8:	d3 e0                	shl    %cl,%eax
  4063fa:	89 44 24 60          	mov    %eax,0x60(%rsp)
        if (fcs_state_col_is_empty(state, ret))
  4063fe:	48 8b 06             	mov    (%rsi),%rax
  406401:	80 38 00             	cmpb   $0x0,(%rax)
  406404:	0f 84 0b 0e 00 00    	je     407215 <fc_solve_sfs_move_sequences_to_free_stacks+0xe55>
  40640a:	48 8b 46 08          	mov    0x8(%rsi),%rax
  40640e:	80 38 00             	cmpb   $0x0,(%rax)
  406411:	0f 84 78 0e 00 00    	je     40728f <fc_solve_sfs_move_sequences_to_free_stacks+0xecf>
  406417:	48 8b 46 10          	mov    0x10(%rsi),%rax
  40641b:	80 38 00             	cmpb   $0x0,(%rax)
  40641e:	0f 84 5e 0e 00 00    	je     407282 <fc_solve_sfs_move_sequences_to_free_stacks+0xec2>
  406424:	48 8b 46 18          	mov    0x18(%rsi),%rax
  406428:	80 38 00             	cmpb   $0x0,(%rax)
  40642b:	0f 84 6b 0e 00 00    	je     40729c <fc_solve_sfs_move_sequences_to_free_stacks+0xedc>
  406431:	48 8b 46 20          	mov    0x20(%rsi),%rax
  406435:	80 38 00             	cmpb   $0x0,(%rax)
  406438:	0f 84 af 0d 00 00    	je     4071ed <fc_solve_sfs_move_sequences_to_free_stacks+0xe2d>
  40643e:	48 8b 46 28          	mov    0x28(%rsi),%rax
  406442:	80 38 00             	cmpb   $0x0,(%rax)
  406445:	0f 84 87 0e 00 00    	je     4072d2 <fc_solve_sfs_move_sequences_to_free_stacks+0xf12>
  40644b:	48 8b 46 30          	mov    0x30(%rsi),%rax
  40644f:	80 38 00             	cmpb   $0x0,(%rax)
  406452:	0f 84 87 0e 00 00    	je     4072df <fc_solve_sfs_move_sequences_to_free_stacks+0xf1f>
  406458:	48 8b 4e 38          	mov    0x38(%rsi),%rcx
  40645c:	c7 44 24 64 00 00 00 	movl   $0x0,0x64(%rsp)
  406463:	00 
  406464:	48 c7 c0 80 ff ff ff 	mov    $0xffffffffffffff80,%rax
    return -1;
  40646b:	c7 44 24 68 ff ff ff 	movl   $0xffffffff,0x68(%rsp)
  406472:	ff 
        if (fcs_state_col_is_empty(state, ret))
  406473:	80 39 00             	cmpb   $0x0,(%rcx)
  406476:	0f 84 49 0e 00 00    	je     4072c5 <fc_solve_sfs_move_sequences_to_free_stacks+0xf05>
    MOVE_FUNCS__define_common();
  40647c:	48 8b 1f             	mov    (%rdi),%rbx
  40647f:	4c 89 44 24 20       	mov    %r8,0x20(%rsp)
  406484:	48 89 54 24 58       	mov    %rdx,0x58(%rsp)
  406489:	48 89 74 24 10       	mov    %rsi,0x10(%rsp)
  40648e:	48 89 7c 24 30       	mov    %rdi,0x30(%rsp)
  406493:	48 89 5c 24 50       	mov    %rbx,0x50(%rsp)
  406498:	48 81 c3 00 01 00 00 	add    $0x100,%rbx
                copy_two_stacks(stack_idx, ds);
  40649f:	48 01 d8             	add    %rbx,%rax
    MOVE_FUNCS__define_common();
  4064a2:	48 89 5c 24 78       	mov    %rbx,0x78(%rsp)
                copy_two_stacks(stack_idx, ds);
  4064a7:	48 89 44 24 70       	mov    %rax,0x70(%rsp)
  4064ac:	48 89 5c 24 38       	mov    %rbx,0x38(%rsp)
  4064b1:	48 c7 44 24 08 00 00 	movq   $0x0,0x8(%rsp)
  4064b8:	00 00 
    return -1;
  4064ba:	44 89 6c 24 6c       	mov    %r13d,0x6c(%rsp)
  4064bf:	90                   	nop
  4064c0:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
    ret.col = fcs_state_get_col(*s, stack_idx);
  4064c5:	48 8b 5c 24 10       	mov    0x10(%rsp),%rbx
  4064ca:	89 44 24 28          	mov    %eax,0x28(%rsp)
  4064ce:	4c 8b 34 c3          	mov    (%rbx,%rax,8),%r14
    ret.col_len_minus_1 = (ret.col_len = fcs_col_len(ret.col)) - 1;
  4064d2:	4d 0f be 3e          	movsbq (%r14),%r15
  4064d6:	4d 8d 5f ff          	lea    -0x1(%r15),%r11
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4064da:	4d 85 db             	test   %r11,%r11
  4064dd:	0f 8e 27 0c 00 00    	jle    40710a <fc_solve_sfs_move_sequences_to_free_stacks+0xd4a>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  4064e3:	49 0f be 46 01       	movsbq 0x1(%r14),%rax
  4064e8:	49 0f be 56 02       	movsbq 0x2(%r14),%rdx
  4064ed:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  4064f1:	80 bc 02 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rdx,%rax,1)
  4064f8:	00 
  4064f9:	0f 84 0b 0c 00 00    	je     40710a <fc_solve_sfs_move_sequences_to_free_stacks+0xd4a>
  4064ff:	b8 01 00 00 00       	mov    $0x1,%eax
  406504:	eb 28                	jmp    40652e <fc_solve_sfs_move_sequences_to_free_stacks+0x16e>
  406506:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40650d:	00 00 00 
  406510:	49 0f be 54 06 01    	movsbq 0x1(%r14,%rax,1),%rdx
  406516:	49 0f be 4c 06 02    	movsbq 0x2(%r14,%rax,1),%rcx
  40651c:	48 83 c0 01          	add    $0x1,%rax
  406520:	48 c1 e2 06          	shl    $0x6,%rdx
  406524:	80 bc 11 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rcx,%rdx,1)
  40652b:	00 
  40652c:	74 08                	je     406536 <fc_solve_sfs_move_sequences_to_free_stacks+0x176>
         ++((*iter).seq_end))
  40652e:	48 89 c5             	mov    %rax,%rbp
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  406531:	49 39 c3             	cmp    %rax,%r11
  406534:	75 da                	jne    406510 <fc_solve_sfs_move_sequences_to_free_stacks+0x150>
    return ret;
  406536:	0f b6 4c 24 28       	movzbl 0x28(%rsp),%ecx
  40653b:	b8 01 00 00 00       	mov    $0x1,%eax
  406540:	d3 e0                	shl    %cl,%eax
  406542:	89 44 24 2c          	mov    %eax,0x2c(%rsp)
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  406546:	4d 85 ff             	test   %r15,%r15
  406549:	0f 8e e0 00 00 00    	jle    40662f <fc_solve_sfs_move_sequences_to_free_stacks+0x26f>
                sfs_check_state_begin();
  40654f:	44 8b 6c 24 6c       	mov    0x6c(%rsp),%r13d
    return ret;
  406554:	31 d2                	xor    %edx,%edx
                sfs_check_state_begin();
  406556:	4c 89 db             	mov    %r11,%rbx
  406559:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            if (iter.seq_end == iter.col_len_minus_1)
  406560:	48 39 eb             	cmp    %rbp,%rbx
  406563:	0f 84 f7 00 00 00    	je     406660 <fc_solve_sfs_move_sequences_to_free_stacks+0x2a0>
                int num_cards_to_relocate = iter.col_len_minus_1 - iter.seq_end;
  406569:	41 89 dc             	mov    %ebx,%r12d
                if (!((num_cards_to_relocate == 0) &&
  40656c:	8b 7c 24 04          	mov    0x4(%rsp),%edi
                int num_cards_to_relocate = iter.col_len_minus_1 - iter.seq_end;
  406570:	89 e8                	mov    %ebp,%eax
  406572:	41 29 ec             	sub    %ebp,%r12d
                const int freecells_to_fill =
  406575:	45 39 e5             	cmp    %r12d,%r13d
  406578:	44 89 e6             	mov    %r12d,%esi
                num_cards_to_relocate -= freecells_to_fill;
  40657b:	44 89 e1             	mov    %r12d,%ecx
                const int freecells_to_fill =
  40657e:	41 0f 4e f5          	cmovle %r13d,%esi
                num_cards_to_relocate -= freecells_to_fill;
  406582:	29 f1                	sub    %esi,%ecx
                if (!((num_cards_to_relocate == 0) &&
  406584:	39 cf                	cmp    %ecx,%edi
  406586:	7c 36                	jl     4065be <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
                        (num_vacant_stacks - freestacks_to_fill > 0)))
  406588:	29 cf                	sub    %ecx,%edi
  40658a:	89 f9                	mov    %edi,%ecx
                if (!((num_cards_to_relocate == 0) &&
  40658c:	85 ff                	test   %edi,%edi
  40658e:	7e 2e                	jle    4065be <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
                    const int max_seq_move = calc_max_sequence_move(
  406590:	44 89 ef             	mov    %r13d,%edi
  406593:	83 e9 01             	sub    $0x1,%ecx
                    const int m = iter.seq_end + 1 - max_seq_move;
  406596:	83 c0 01             	add    $0x1,%eax
                    const int max_seq_move = calc_max_sequence_move(
  406599:	29 f7                	sub    %esi,%edi
  40659b:	89 fe                	mov    %edi,%esi
  40659d:	83 c6 01             	add    $0x1,%esi
  4065a0:	d3 e6                	shl    %cl,%esi
                    const int m = iter.seq_end + 1 - max_seq_move;
  4065a2:	29 f0                	sub    %esi,%eax
                    max(m, iter.c);
  4065a4:	48 98                	cltq   
  4065a6:	48 39 d0             	cmp    %rdx,%rax
  4065a9:	48 0f 4d d0          	cmovge %rax,%rdx
                if (!((seq_start <= iter.seq_end) &&
  4065ad:	48 63 c2             	movslq %edx,%rax
  4065b0:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
  4065b5:	48 39 e8             	cmp    %rbp,%rax
  4065b8:	0f 8e 72 02 00 00    	jle    406830 <fc_solve_sfs_move_sequences_to_free_stacks+0x470>
    iter->c = iter->seq_end + 1;
  4065be:	48 8d 55 01          	lea    0x1(%rbp),%rdx
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4065c2:	48 39 d3             	cmp    %rdx,%rbx
  4065c5:	0f 8e 45 02 00 00    	jle    406810 <fc_solve_sfs_move_sequences_to_free_stacks+0x450>
  4065cb:	49 0f be 44 2e 02    	movsbq 0x2(%r14,%rbp,1),%rax
  4065d1:	49 0f be 4c 2e 03    	movsbq 0x3(%r14,%rbp,1),%rcx
  4065d7:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  4065db:	80 bc 01 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rcx,%rax,1)
  4065e2:	00 
  4065e3:	0f 84 27 02 00 00    	je     406810 <fc_solve_sfs_move_sequences_to_free_stacks+0x450>
  4065e9:	48 8d 45 02          	lea    0x2(%rbp),%rax
  4065ed:	49 8d 7f ff          	lea    -0x1(%r15),%rdi
  4065f1:	eb 2b                	jmp    40661e <fc_solve_sfs_move_sequences_to_free_stacks+0x25e>
  4065f3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4065fa:	00 00 00 00 
  4065fe:	66 90                	xchg   %ax,%ax
  406600:	49 0f be 4c 06 01    	movsbq 0x1(%r14,%rax,1),%rcx
  406606:	49 0f be 74 06 02    	movsbq 0x2(%r14,%rax,1),%rsi
  40660c:	48 83 c0 01          	add    $0x1,%rax
  406610:	48 c1 e1 06          	shl    $0x6,%rcx
  406614:	80 bc 0e c0 05 41 00 	cmpb   $0x0,0x4105c0(%rsi,%rcx,1)
  40661b:	00 
  40661c:	74 08                	je     406626 <fc_solve_sfs_move_sequences_to_free_stacks+0x266>
         ++((*iter).seq_end))
  40661e:	48 89 c5             	mov    %rax,%rbp
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  406621:	48 39 c7             	cmp    %rax,%rdi
  406624:	75 da                	jne    406600 <fc_solve_sfs_move_sequences_to_free_stacks+0x240>
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  406626:	49 39 d7             	cmp    %rdx,%r15
  406629:	0f 8f 31 ff ff ff    	jg     406560 <fc_solve_sfs_move_sequences_to_free_stacks+0x1a0>
  40662f:	48 83 44 24 08 01    	addq   $0x1,0x8(%rsp)
  406635:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  40663a:	48 83 6c 24 38 80    	subq   $0xffffffffffffff80,0x38(%rsp)
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  406640:	48 83 f8 08          	cmp    $0x8,%rax
  406644:	0f 85 76 fe ff ff    	jne    4064c0 <fc_solve_sfs_move_sequences_to_free_stacks+0x100>
}
  40664a:	48 81 c4 b8 00 00 00 	add    $0xb8,%rsp
  406651:	5b                   	pop    %rbx
  406652:	5d                   	pop    %rbp
  406653:	41 5c                	pop    %r12
  406655:	41 5d                	pop    %r13
  406657:	41 5e                	pop    %r14
  406659:	41 5f                	pop    %r15
  40665b:	c3                   	retq   
  40665c:	0f 1f 40 00          	nopl   0x0(%rax)
                while ((max_sequence_len < iter.col_len - c) && (c > 0))
  406660:	48 63 74 24 60       	movslq 0x60(%rsp),%rsi
  406665:	48 63 c2             	movslq %edx,%rax
  406668:	4d 89 fc             	mov    %r15,%r12
                int c = iter.c;
  40666b:	89 d1                	mov    %edx,%ecx
                while ((max_sequence_len < iter.col_len - c) && (c > 0))
  40666d:	49 29 c4             	sub    %rax,%r12
  406670:	4c 39 e6             	cmp    %r12,%rsi
  406673:	7d 32                	jge    4066a7 <fc_solve_sfs_move_sequences_to_free_stacks+0x2e7>
  406675:	85 d2                	test   %edx,%edx
  406677:	0f 8e 41 ff ff ff    	jle    4065be <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
  40667d:	48 83 e8 01          	sub    $0x1,%rax
  406681:	4c 89 ff             	mov    %r15,%rdi
  406684:	48 29 c7             	sub    %rax,%rdi
  406687:	48 89 f8             	mov    %rdi,%rax
  40668a:	eb 10                	jmp    40669c <fc_solve_sfs_move_sequences_to_free_stacks+0x2dc>
  40668c:	0f 1f 40 00          	nopl   0x0(%rax)
  406690:	48 83 c0 01          	add    $0x1,%rax
  406694:	85 c9                	test   %ecx,%ecx
  406696:	0f 84 22 ff ff ff    	je     4065be <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
                    c--;
  40669c:	83 e9 01             	sub    $0x1,%ecx
                while ((max_sequence_len < iter.col_len - c) && (c > 0))
  40669f:	49 89 c4             	mov    %rax,%r12
  4066a2:	48 39 f0             	cmp    %rsi,%rax
  4066a5:	7f e9                	jg     406690 <fc_solve_sfs_move_sequences_to_free_stacks+0x2d0>
                if (!((c > 0) && ((IS_FILLED_BY_KINGS_ONLY())
  4066a7:	85 c9                	test   %ecx,%ecx
  4066a9:	0f 8e 0f ff ff ff    	jle    4065be <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
                sfs_check_state_begin();
  4066af:	48 8b 4c 24 58       	mov    0x58(%rsp),%rcx
  4066b4:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  4066bb:	00 
  4066bc:	48 8b 7c 24 50       	mov    0x50(%rsp),%rdi
  4066c1:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  4066c6:	e8 55 b3 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
                copy_two_stacks(stack_idx, ds);
  4066cb:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  4066d2:	00 
  4066d3:	8b 4f 14             	mov    0x14(%rdi),%ecx
  4066d6:	85 4c 24 2c          	test   %ecx,0x2c(%rsp)
  4066da:	0f 84 50 05 00 00    	je     406c30 <fc_solve_sfs_move_sequences_to_free_stacks+0x870>
  4066e0:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4066e7:	00 
  4066e8:	48 63 54 24 68       	movslq 0x68(%rsp),%rdx
  4066ed:	85 4c 24 64          	test   %ecx,0x64(%rsp)
  4066f1:	0f 84 d9 04 00 00    	je     406bd0 <fc_solve_sfs_move_sequences_to_free_stacks+0x810>
  4066f7:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
    const size_t cards_size = (((size_t)cards_num) * sizeof(fcs_card));
  4066fc:	4d 63 c4             	movslq %r12d,%r8
  4066ff:	4c 8b 0c d0          	mov    (%rax,%rdx,8),%r9
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  406703:	4c 89 c2             	mov    %r8,%rdx
  406706:	4c 89 44 24 40       	mov    %r8,0x40(%rsp)
  40670b:	48 8b 0c f8          	mov    (%rax,%rdi,8),%rcx
  40670f:	4c 89 4c 24 48       	mov    %r9,0x48(%rsp)
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  406714:	0f b6 01             	movzbl (%rcx),%eax
  406717:	44 29 e0             	sub    %r12d,%eax
  40671a:	88 01                	mov    %al,(%rcx)
  40671c:	48 0f be c0          	movsbq %al,%rax
    fcs_card *const src_cards_ptr =
  406720:	48 8d 4c 01 01       	lea    0x1(%rcx,%rax,1),%rcx
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  406725:	49 0f be 01          	movsbq (%r9),%rax
  406729:	48 89 ce             	mov    %rcx,%rsi
  40672c:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
  406731:	49 8d 7c 01 01       	lea    0x1(%r9,%rax,1),%rdi
  406736:	e8 a5 a9 ff ff       	callq  4010e0 <memcpy@plt>
    fcs_col_len(dest_col) += cards_num;
  40673b:	4c 8b 4c 24 48       	mov    0x48(%rsp),%r9
    memset(src_cards_ptr, 0, cards_size);
  406740:	31 f6                	xor    %esi,%esi
  406742:	4c 8b 44 24 40       	mov    0x40(%rsp),%r8
  406747:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
    fcs_col_len(dest_col) += cards_num;
  40674c:	45 00 21             	add    %r12b,(%r9)
    memset(src_cards_ptr, 0, cards_size);
  40674f:	4c 89 c2             	mov    %r8,%rdx
  406752:	48 89 cf             	mov    %rcx,%rdi
  406755:	e8 46 a9 ff ff       	callq  4010a0 <memset@plt>
    const_SLOT(hard_thread, soft_thread);
  40675a:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  40675f:	48 8d 94 24 a0 00 00 	lea    0xa0(%rsp),%rdx
  406766:	00 
  406767:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  40676e:	00 
    const_SLOT(hard_thread, soft_thread);
  40676f:	4c 8b 20             	mov    (%rax),%r12
    if (!fc_solve_check_and_add_state(
  406772:	4c 89 e7             	mov    %r12,%rdi
  406775:	e8 f6 b3 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  40677a:	84 c0                	test   %al,%al
  40677c:	0f 85 3e 03 00 00    	jne    406ac0 <fc_solve_sfs_move_sequences_to_free_stacks+0x700>
        if (HT_FIELD(hard_thread, allocated_from_list))
  406782:	41 80 bc 24 18 05 00 	cmpb   $0x0,0x518(%r12)
  406789:	00 00 
  40678b:	0f 84 0f 08 00 00    	je     406fa0 <fc_solve_sfs_move_sequences_to_free_stacks+0xbe0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  406791:	49 8b 94 24 b0 00 00 	mov    0xb0(%r12),%rdx
  406798:	00 
  406799:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  4067a0:	00 
  4067a1:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  4067a4:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4067ab:	00 
  4067ac:	49 89 84 24 b0 00 00 	mov    %rax,0xb0(%r12)
  4067b3:	00 
        return FCS_STATE_kv_to_collectible(&existing_state);
  4067b4:	4c 8b a4 24 a0 00 00 	mov    0xa0(%rsp),%r12
  4067bb:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  4067bc:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  4067c1:	31 c9                	xor    %ecx,%ecx
  4067c3:	48 8b 10             	mov    (%rax),%rdx
  4067c6:	48 8b 40 08          	mov    0x8(%rax),%rax
  4067ca:	48 85 c0             	test   %rax,%rax
  4067cd:	0f 95 c1             	setne  %cl
  4067d0:	48 01 d1             	add    %rdx,%rcx
  4067d3:	f6 c1 0f             	test   $0xf,%cl
  4067d6:	0f 84 c4 04 00 00    	je     406ca0 <fc_solve_sfs_move_sequences_to_free_stacks+0x8e0>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  4067dc:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  4067e1:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  4067e5:	48 c1 e2 04          	shl    $0x4,%rdx
  4067e9:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4067ed:	48 01 d0             	add    %rdx,%rax
    iter->c = iter->seq_end + 1;
  4067f0:	48 8d 55 01          	lea    0x1(%rbp),%rdx
  4067f4:	48 89 0f             	mov    %rcx,(%rdi)
  4067f7:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4067fb:	4c 89 20             	mov    %r12,(%rax)
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4067fe:	48 39 d3             	cmp    %rdx,%rbx
  406801:	0f 8f c4 fd ff ff    	jg     4065cb <fc_solve_sfs_move_sequences_to_free_stacks+0x20b>
  406807:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40680e:	00 00 
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  406810:	48 89 d5             	mov    %rdx,%rbp
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  406813:	49 39 d7             	cmp    %rdx,%r15
  406816:	0f 8f 44 fd ff ff    	jg     406560 <fc_solve_sfs_move_sequences_to_free_stacks+0x1a0>
  40681c:	e9 0e fe ff ff       	jmpq   40662f <fc_solve_sfs_move_sequences_to_free_stacks+0x26f>
  406821:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  406828:	00 00 00 00 
  40682c:	0f 1f 40 00          	nopl   0x0(%rax)
                sfs_check_state_begin();
  406830:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  406835:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  40683c:	00 
  40683d:	48 8b 4c 24 58       	mov    0x58(%rsp),%rcx
  406842:	48 8b 7c 24 50       	mov    0x50(%rsp),%rdi
  406847:	e8 d4 b1 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
                my_copy_stack(stack_idx);
  40684c:	48 8b 94 24 98 00 00 	mov    0x98(%rsp),%rdx
  406853:	00 
  406854:	8b 42 14             	mov    0x14(%rdx),%eax
  406857:	85 44 24 2c          	test   %eax,0x2c(%rsp)
  40685b:	0f 84 ff 02 00 00    	je     406b60 <fc_solve_sfs_move_sequences_to_free_stacks+0x7a0>
  406861:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406868:	00 
                const int cols_indexes[3] = {stack_idx, -1, -1};
  406869:	8b 54 24 28          	mov    0x28(%rsp),%edx
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  40686d:	44 89 a4 24 a0 00 00 	mov    %r12d,0xa0(%rsp)
  406874:	00 
                    empty_two_cols_from_new_state(soft_thread,
  406875:	48 8b 7c 24 30       	mov    0x30(%rsp),%rdi
                const int cols_indexes[3] = {stack_idx, -1, -1};
  40687a:	48 c7 84 24 88 00 00 	movq   $0xffffffffffffffff,0x88(%rsp)
  406881:	00 ff ff ff ff 
  406886:	89 94 24 84 00 00 00 	mov    %edx,0x84(%rsp)
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  40688d:	48 ba 00 00 00 00 ff 	movabs $0xffffffff00000000,%rdx
  406894:	ff ff ff 
                    empty_two_cols_from_new_state(soft_thread,
  406897:	4c 8b 0f             	mov    (%rdi),%r9
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  40689a:	48 89 94 24 a4 00 00 	mov    %rdx,0xa4(%rsp)
  4068a1:	00 
            while ((*col_num_cards) == 0)
  4068a2:	45 85 e4             	test   %r12d,%r12d
  4068a5:	0f 85 25 04 00 00    	jne    406cd0 <fc_solve_sfs_move_sequences_to_free_stacks+0x910>
        if (fcs_state_col_is_empty(state, ret))
  4068ab:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  4068b0:	48 89 c1             	mov    %rax,%rcx
  4068b3:	48 8b 07             	mov    (%rdi),%rax
  4068b6:	80 38 00             	cmpb   $0x0,(%rax)
  4068b9:	0f 84 92 06 00 00    	je     406f51 <fc_solve_sfs_move_sequences_to_free_stacks+0xb91>
  4068bf:	90                   	nop
  4068c0:	48 8b 47 08          	mov    0x8(%rdi),%rax
  4068c4:	80 38 00             	cmpb   $0x0,(%rax)
  4068c7:	0f 84 89 08 00 00    	je     407156 <fc_solve_sfs_move_sequences_to_free_stacks+0xd96>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4068cd:	41 b8 02 00 00 00    	mov    $0x2,%r8d
        if (fcs_state_col_is_empty(state, ret))
  4068d3:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  4068d8:	49 63 c0             	movslq %r8d,%rax
  4068db:	48 8b 14 c7          	mov    (%rdi,%rax,8),%rdx
  4068df:	80 3a 00             	cmpb   $0x0,(%rdx)
  4068e2:	0f 84 cd 01 00 00    	je     406ab5 <fc_solve_sfs_move_sequences_to_free_stacks+0x6f5>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4068e8:	41 8d 50 01          	lea    0x1(%r8),%edx
  4068ec:	83 fa 08             	cmp    $0x8,%edx
  4068ef:	74 6e                	je     40695f <fc_solve_sfs_move_sequences_to_free_stacks+0x59f>
        if (fcs_state_col_is_empty(state, ret))
  4068f1:	48 63 c2             	movslq %edx,%rax
  4068f4:	48 8b 34 c7          	mov    (%rdi,%rax,8),%rsi
  4068f8:	80 3e 00             	cmpb   $0x0,(%rsi)
  4068fb:	0f 84 fe 07 00 00    	je     4070ff <fc_solve_sfs_move_sequences_to_free_stacks+0xd3f>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406901:	41 8d 50 02          	lea    0x2(%r8),%edx
  406905:	83 fa 08             	cmp    $0x8,%edx
  406908:	74 55                	je     40695f <fc_solve_sfs_move_sequences_to_free_stacks+0x59f>
        if (fcs_state_col_is_empty(state, ret))
  40690a:	48 63 c2             	movslq %edx,%rax
  40690d:	48 8b 34 c7          	mov    (%rdi,%rax,8),%rsi
  406911:	80 3e 00             	cmpb   $0x0,(%rsi)
  406914:	0f 84 e5 07 00 00    	je     4070ff <fc_solve_sfs_move_sequences_to_free_stacks+0xd3f>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40691a:	41 8d 50 03          	lea    0x3(%r8),%edx
  40691e:	83 fa 08             	cmp    $0x8,%edx
  406921:	74 3c                	je     40695f <fc_solve_sfs_move_sequences_to_free_stacks+0x59f>
        if (fcs_state_col_is_empty(state, ret))
  406923:	48 63 c2             	movslq %edx,%rax
  406926:	48 8b 34 c7          	mov    (%rdi,%rax,8),%rsi
  40692a:	80 3e 00             	cmpb   $0x0,(%rsi)
  40692d:	0f 84 cc 07 00 00    	je     4070ff <fc_solve_sfs_move_sequences_to_free_stacks+0xd3f>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406933:	41 8d 50 04          	lea    0x4(%r8),%edx
  406937:	83 fa 08             	cmp    $0x8,%edx
  40693a:	74 23                	je     40695f <fc_solve_sfs_move_sequences_to_free_stacks+0x59f>
        if (fcs_state_col_is_empty(state, ret))
  40693c:	48 63 c2             	movslq %edx,%rax
  40693f:	48 8b 34 c7          	mov    (%rdi,%rax,8),%rsi
  406943:	80 3e 00             	cmpb   $0x0,(%rsi)
  406946:	0f 84 b3 07 00 00    	je     4070ff <fc_solve_sfs_move_sequences_to_free_stacks+0xd3f>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40694c:	41 83 f8 02          	cmp    $0x2,%r8d
  406950:	75 0d                	jne    40695f <fc_solve_sfs_move_sequences_to_free_stacks+0x59f>
        if (fcs_state_col_is_empty(state, ret))
  406952:	48 8b 47 38          	mov    0x38(%rdi),%rax
  406956:	80 38 00             	cmpb   $0x0,(%rax)
  406959:	0f 84 4b 01 00 00    	je     406aaa <fc_solve_sfs_move_sequences_to_free_stacks+0x6ea>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40695f:	48 c7 c2 ff ff ff ff 	mov    $0xffffffffffffffff,%rdx
    return -1;
  406966:	41 b8 ff ff ff ff    	mov    $0xffffffff,%r8d
                my_copy_stack(b);
  40696c:	48 8b b4 24 98 00 00 	mov    0x98(%rsp),%rsi
  406973:	00 
  406974:	8b 46 14             	mov    0x14(%rsi),%eax
  406977:	44 0f a3 c0          	bt     %r8d,%eax
  40697b:	0f 83 4f 01 00 00    	jae    406ad0 <fc_solve_sfs_move_sequences_to_free_stacks+0x710>
  406981:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
                fcs_move_sequence(b, stack_idx, iter.seq_end - seq_start + 1);
  406986:	49 89 ec             	mov    %rbp,%r12
  406989:	4c 2b 64 24 18       	sub    0x18(%rsp),%r12
  40698e:	4c 8b 0c d1          	mov    (%rcx,%rdx,8),%r9
  406992:	48 8b 04 c1          	mov    (%rcx,%rax,8),%rax
  406996:	49 83 c4 01          	add    $0x1,%r12
    const size_t cards_size = (((size_t)cards_num) * sizeof(fcs_card));
  40699a:	4d 63 c4             	movslq %r12d,%r8
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  40699d:	4c 89 4c 24 48       	mov    %r9,0x48(%rsp)
  4069a2:	4c 89 44 24 40       	mov    %r8,0x40(%rsp)
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  4069a7:	0f b6 10             	movzbl (%rax),%edx
  4069aa:	44 29 e2             	sub    %r12d,%edx
  4069ad:	88 10                	mov    %dl,(%rax)
  4069af:	48 0f be d2          	movsbq %dl,%rdx
    fcs_card *const src_cards_ptr =
  4069b3:	48 8d 4c 10 01       	lea    0x1(%rax,%rdx,1),%rcx
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  4069b8:	49 0f be 01          	movsbq (%r9),%rax
  4069bc:	4c 89 c2             	mov    %r8,%rdx
  4069bf:	48 89 ce             	mov    %rcx,%rsi
  4069c2:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
  4069c7:	49 8d 7c 01 01       	lea    0x1(%r9,%rax,1),%rdi
  4069cc:	e8 0f a7 ff ff       	callq  4010e0 <memcpy@plt>
    fcs_col_len(dest_col) += cards_num;
  4069d1:	4c 8b 4c 24 48       	mov    0x48(%rsp),%r9
    memset(src_cards_ptr, 0, cards_size);
  4069d6:	31 f6                	xor    %esi,%esi
  4069d8:	4c 8b 44 24 40       	mov    0x40(%rsp),%r8
  4069dd:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
    fcs_col_len(dest_col) += cards_num;
  4069e2:	45 00 21             	add    %r12b,(%r9)
    memset(src_cards_ptr, 0, cards_size);
  4069e5:	4c 89 c2             	mov    %r8,%rdx
  4069e8:	48 89 cf             	mov    %rcx,%rdi
  4069eb:	e8 b0 a6 ff ff       	callq  4010a0 <memset@plt>
    const_SLOT(hard_thread, soft_thread);
  4069f0:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  4069f5:	48 8d 94 24 a0 00 00 	lea    0xa0(%rsp),%rdx
  4069fc:	00 
  4069fd:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  406a04:	00 
    const_SLOT(hard_thread, soft_thread);
  406a05:	4c 8b 20             	mov    (%rax),%r12
    if (!fc_solve_check_and_add_state(
  406a08:	4c 89 e7             	mov    %r12,%rdi
  406a0b:	e8 60 b1 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  406a10:	84 c0                	test   %al,%al
  406a12:	0f 85 88 00 00 00    	jne    406aa0 <fc_solve_sfs_move_sequences_to_free_stacks+0x6e0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  406a18:	41 80 bc 24 18 05 00 	cmpb   $0x0,0x518(%r12)
  406a1f:	00 00 
  406a21:	0f 84 59 05 00 00    	je     406f80 <fc_solve_sfs_move_sequences_to_free_stacks+0xbc0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  406a27:	49 8b 94 24 b0 00 00 	mov    0xb0(%r12),%rdx
  406a2e:	00 
  406a2f:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  406a36:	00 
  406a37:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  406a3a:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406a41:	00 
  406a42:	49 89 84 24 b0 00 00 	mov    %rax,0xb0(%r12)
  406a49:	00 
        return FCS_STATE_kv_to_collectible(&existing_state);
  406a4a:	4c 8b a4 24 a0 00 00 	mov    0xa0(%rsp),%r12
  406a51:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  406a52:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  406a57:	31 d2                	xor    %edx,%edx
  406a59:	48 8b 38             	mov    (%rax),%rdi
  406a5c:	48 8b 40 08          	mov    0x8(%rax),%rax
  406a60:	48 85 c0             	test   %rax,%rax
  406a63:	0f 95 c2             	setne  %dl
  406a66:	48 01 fa             	add    %rdi,%rdx
  406a69:	f6 c2 0f             	test   $0xf,%dl
  406a6c:	0f 84 be 00 00 00    	je     406b30 <fc_solve_sfs_move_sequences_to_free_stacks+0x770>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  406a72:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  406a77:	48 8d 57 01          	lea    0x1(%rdi),%rdx
  406a7b:	48 c1 e7 04          	shl    $0x4,%rdi
  406a7f:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  406a83:	48 01 f8             	add    %rdi,%rax
  406a86:	48 89 16             	mov    %rdx,(%rsi)
  406a89:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  406a8d:	4c 89 20             	mov    %r12,(%rax)
  406a90:	e9 29 fb ff ff       	jmpq   4065be <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
  406a95:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  406a9c:	00 00 00 00 
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  406aa0:	4c 8b a4 24 90 00 00 	mov    0x90(%rsp),%r12
  406aa7:	00 
  406aa8:	eb a8                	jmp    406a52 <fc_solve_sfs_move_sequences_to_free_stacks+0x692>
        if (fcs_state_col_is_empty(state, ret))
  406aaa:	41 b8 07 00 00 00    	mov    $0x7,%r8d
  406ab0:	b8 07 00 00 00       	mov    $0x7,%eax
  406ab5:	48 89 c2             	mov    %rax,%rdx
  406ab8:	e9 af fe ff ff       	jmpq   40696c <fc_solve_sfs_move_sequences_to_free_stacks+0x5ac>
  406abd:	0f 1f 00             	nopl   (%rax)
  406ac0:	4c 8b a4 24 90 00 00 	mov    0x90(%rsp),%r12
  406ac7:	00 
  406ac8:	e9 ef fc ff ff       	jmpq   4067bc <fc_solve_sfs_move_sequences_to_free_stacks+0x3fc>
  406acd:	0f 1f 00             	nopl   (%rax)
                my_copy_stack(b);
  406ad0:	44 0f ab c0          	bts    %r8d,%eax
  406ad4:	89 46 14             	mov    %eax,0x14(%rsi)
  406ad7:	49 63 c0             	movslq %r8d,%rax
  406ada:	41 c1 e0 07          	shl    $0x7,%r8d
  406ade:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  406ae2:	4d 63 c0             	movslq %r8d,%r8
  406ae5:	4c 03 44 24 78       	add    0x78(%rsp),%r8
  406aea:	0f be 0e             	movsbl (%rsi),%ecx
  406aed:	83 c1 01             	add    $0x1,%ecx
  406af0:	48 63 c9             	movslq %ecx,%rcx
  406af3:	48 83 f9 08          	cmp    $0x8,%rcx
  406af7:	0f 83 e3 04 00 00    	jae    406fe0 <fc_solve_sfs_move_sequences_to_free_stacks+0xc20>
  406afd:	f6 c1 04             	test   $0x4,%cl
  406b00:	0f 85 72 06 00 00    	jne    407178 <fc_solve_sfs_move_sequences_to_free_stacks+0xdb8>
  406b06:	48 85 c9             	test   %rcx,%rcx
  406b09:	74 0f                	je     406b1a <fc_solve_sfs_move_sequences_to_free_stacks+0x75a>
  406b0b:	0f b6 3e             	movzbl (%rsi),%edi
  406b0e:	41 88 38             	mov    %dil,(%r8)
  406b11:	f6 c1 02             	test   $0x2,%cl
  406b14:	0f 85 34 07 00 00    	jne    40724e <fc_solve_sfs_move_sequences_to_free_stacks+0xe8e>
  406b1a:	48 8b 8c 24 90 00 00 	mov    0x90(%rsp),%rcx
  406b21:	00 
  406b22:	4c 89 04 c1          	mov    %r8,(%rcx,%rax,8)
  406b26:	e9 56 fe ff ff       	jmpq   406981 <fc_solve_sfs_move_sequences_to_free_stacks+0x5c1>
  406b2b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  406b30:	48 8d 72 10          	lea    0x10(%rdx),%rsi
  406b34:	48 89 c7             	mov    %rax,%rdi
  406b37:	48 c1 e6 04          	shl    $0x4,%rsi
  406b3b:	e8 30 a6 ff ff       	callq  401170 <realloc@plt>
        list->states =
  406b40:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  406b45:	48 89 47 08          	mov    %rax,0x8(%rdi)
  406b49:	48 8b 3f             	mov    (%rdi),%rdi
  406b4c:	e9 21 ff ff ff       	jmpq   406a72 <fc_solve_sfs_move_sequences_to_free_stacks+0x6b2>
  406b51:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  406b58:	00 00 00 00 
  406b5c:	0f 1f 40 00          	nopl   0x0(%rax)
                my_copy_stack(stack_idx);
  406b60:	0b 44 24 2c          	or     0x2c(%rsp),%eax
  406b64:	4c 63 44 24 28       	movslq 0x28(%rsp),%r8
  406b69:	89 42 14             	mov    %eax,0x14(%rdx)
  406b6c:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406b73:	00 
  406b74:	4a 8b 34 c0          	mov    (%rax,%r8,8),%rsi
  406b78:	0f be 16             	movsbl (%rsi),%edx
  406b7b:	83 c2 01             	add    $0x1,%edx
  406b7e:	48 63 d2             	movslq %edx,%rdx
  406b81:	48 83 fa 08          	cmp    $0x8,%rdx
  406b85:	0f 83 75 04 00 00    	jae    407000 <fc_solve_sfs_move_sequences_to_free_stacks+0xc40>
  406b8b:	f6 c2 04             	test   $0x4,%dl
  406b8e:	0f 85 f7 05 00 00    	jne    40718b <fc_solve_sfs_move_sequences_to_free_stacks+0xdcb>
  406b94:	48 85 d2             	test   %rdx,%rdx
  406b97:	74 1b                	je     406bb4 <fc_solve_sfs_move_sequences_to_free_stacks+0x7f4>
  406b99:	0f b6 06             	movzbl (%rsi),%eax
  406b9c:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  406ba1:	88 07                	mov    %al,(%rdi)
  406ba3:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406baa:	00 
  406bab:	f6 c2 02             	test   $0x2,%dl
  406bae:	0f 85 7e 06 00 00    	jne    407232 <fc_solve_sfs_move_sequences_to_free_stacks+0xe72>
  406bb4:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  406bb9:	4a 89 3c c0          	mov    %rdi,(%rax,%r8,8)
  406bbd:	e9 a7 fc ff ff       	jmpq   406869 <fc_solve_sfs_move_sequences_to_free_stacks+0x4a9>
  406bc2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  406bc9:	00 00 00 00 
  406bcd:	0f 1f 00             	nopl   (%rax)
                copy_two_stacks(stack_idx, ds);
  406bd0:	0b 4c 24 64          	or     0x64(%rsp),%ecx
  406bd4:	48 8b 34 d0          	mov    (%rax,%rdx,8),%rsi
  406bd8:	89 4f 14             	mov    %ecx,0x14(%rdi)
  406bdb:	0f be 0e             	movsbl (%rsi),%ecx
  406bde:	83 c1 01             	add    $0x1,%ecx
  406be1:	48 63 c9             	movslq %ecx,%rcx
  406be4:	48 83 f9 08          	cmp    $0x8,%rcx
  406be8:	0f 83 c2 04 00 00    	jae    4070b0 <fc_solve_sfs_move_sequences_to_free_stacks+0xcf0>
  406bee:	f6 c1 04             	test   $0x4,%cl
  406bf1:	0f 85 b2 05 00 00    	jne    4071a9 <fc_solve_sfs_move_sequences_to_free_stacks+0xde9>
  406bf7:	48 85 c9             	test   %rcx,%rcx
  406bfa:	74 1b                	je     406c17 <fc_solve_sfs_move_sequences_to_free_stacks+0x857>
  406bfc:	0f b6 06             	movzbl (%rsi),%eax
  406bff:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  406c04:	88 07                	mov    %al,(%rdi)
  406c06:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406c0d:	00 
  406c0e:	f6 c1 02             	test   $0x2,%cl
  406c11:	0f 85 92 06 00 00    	jne    4072a9 <fc_solve_sfs_move_sequences_to_free_stacks+0xee9>
  406c17:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  406c1c:	48 89 3c d0          	mov    %rdi,(%rax,%rdx,8)
  406c20:	e9 d2 fa ff ff       	jmpq   4066f7 <fc_solve_sfs_move_sequences_to_free_stacks+0x337>
  406c25:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  406c2c:	00 00 00 00 
  406c30:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406c37:	00 
  406c38:	4c 63 44 24 28       	movslq 0x28(%rsp),%r8
  406c3d:	0b 4c 24 2c          	or     0x2c(%rsp),%ecx
  406c41:	4a 8b 34 c0          	mov    (%rax,%r8,8),%rsi
  406c45:	89 4f 14             	mov    %ecx,0x14(%rdi)
  406c48:	0f be 0e             	movsbl (%rsi),%ecx
  406c4b:	83 c1 01             	add    $0x1,%ecx
  406c4e:	48 63 c9             	movslq %ecx,%rcx
  406c51:	48 83 f9 08          	cmp    $0x8,%rcx
  406c55:	0f 83 85 04 00 00    	jae    4070e0 <fc_solve_sfs_move_sequences_to_free_stacks+0xd20>
  406c5b:	f6 c1 04             	test   $0x4,%cl
  406c5e:	0f 85 63 05 00 00    	jne    4071c7 <fc_solve_sfs_move_sequences_to_free_stacks+0xe07>
  406c64:	48 85 c9             	test   %rcx,%rcx
  406c67:	74 23                	je     406c8c <fc_solve_sfs_move_sequences_to_free_stacks+0x8cc>
  406c69:	0f b6 06             	movzbl (%rsi),%eax
  406c6c:	48 8b 54 24 38       	mov    0x38(%rsp),%rdx
  406c71:	88 02                	mov    %al,(%rdx)
  406c73:	f6 c1 02             	test   $0x2,%cl
  406c76:	0f 85 e2 05 00 00    	jne    40725e <fc_solve_sfs_move_sequences_to_free_stacks+0xe9e>
  406c7c:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  406c83:	00 
  406c84:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406c8b:	00 
  406c8c:	48 8b 54 24 38       	mov    0x38(%rsp),%rdx
  406c91:	8b 4f 14             	mov    0x14(%rdi),%ecx
  406c94:	4a 89 14 c0          	mov    %rdx,(%rax,%r8,8)
  406c98:	e9 4b fa ff ff       	jmpq   4066e8 <fc_solve_sfs_move_sequences_to_free_stacks+0x328>
  406c9d:	0f 1f 00             	nopl   (%rax)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  406ca0:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  406ca4:	48 89 c7             	mov    %rax,%rdi
  406ca7:	48 c1 e6 04          	shl    $0x4,%rsi
  406cab:	e8 c0 a4 ff ff       	callq  401170 <realloc@plt>
        list->states =
  406cb0:	48 8b 54 24 20       	mov    0x20(%rsp),%rdx
  406cb5:	48 89 42 08          	mov    %rax,0x8(%rdx)
  406cb9:	48 8b 12             	mov    (%rdx),%rdx
  406cbc:	e9 1b fb ff ff       	jmpq   4067dc <fc_solve_sfs_move_sequences_to_free_stacks+0x41c>
  406cc1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  406cc8:	00 00 00 00 
  406ccc:	0f 1f 40 00          	nopl   0x0(%rax)
  406cd0:	4c 63 44 24 28       	movslq 0x28(%rsp),%r8
            while ((*col_num_cards) == 0)
  406cd5:	44 89 e2             	mov    %r12d,%edx
  406cd8:	31 f6                	xor    %esi,%esi
        int dest_fc_idx = 0;
  406cda:	31 ff                	xor    %edi,%edi
  406cdc:	0f 1f 40 00          	nopl   0x0(%rax)
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  406ce0:	4c 63 d7             	movslq %edi,%r10
  406ce3:	42 80 7c 10 40 00    	cmpb   $0x0,0x40(%rax,%r10,1)
  406ce9:	0f 84 13 02 00 00    	je     406f02 <fc_solve_sfs_move_sequences_to_free_stacks+0xb42>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  406cef:	8d 4f 01             	lea    0x1(%rdi),%ecx
  406cf2:	83 f9 04             	cmp    $0x4,%ecx
  406cf5:	74 34                	je     406d2b <fc_solve_sfs_move_sequences_to_free_stacks+0x96b>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  406cf7:	4c 63 d1             	movslq %ecx,%r10
  406cfa:	42 80 7c 10 40 00    	cmpb   $0x0,0x40(%rax,%r10,1)
  406d00:	0f 84 fa 01 00 00    	je     406f00 <fc_solve_sfs_move_sequences_to_free_stacks+0xb40>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  406d06:	8d 4f 02             	lea    0x2(%rdi),%ecx
  406d09:	83 f9 04             	cmp    $0x4,%ecx
  406d0c:	74 1d                	je     406d2b <fc_solve_sfs_move_sequences_to_free_stacks+0x96b>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  406d0e:	4c 63 d1             	movslq %ecx,%r10
  406d11:	42 80 7c 10 40 00    	cmpb   $0x0,0x40(%rax,%r10,1)
  406d17:	0f 84 e3 01 00 00    	je     406f00 <fc_solve_sfs_move_sequences_to_free_stacks+0xb40>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  406d1d:	85 ff                	test   %edi,%edi
  406d1f:	75 0a                	jne    406d2b <fc_solve_sfs_move_sequences_to_free_stacks+0x96b>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  406d21:	80 78 43 00          	cmpb   $0x0,0x43(%rax)
  406d25:	0f 84 a5 02 00 00    	je     406fd0 <fc_solve_sfs_move_sequences_to_free_stacks+0xc10>
  406d2b:	40 84 f6             	test   %sil,%sil
  406d2e:	74 08                	je     406d38 <fc_solve_sfs_move_sequences_to_free_stacks+0x978>
  406d30:	44 89 a4 24 a0 00 00 	mov    %r12d,0xa0(%rsp)
  406d37:	00 
  406d38:	48 8b 8c 24 90 00 00 	mov    0x90(%rsp),%rcx
  406d3f:	00 
    char *const indirect_stacks_buffer =
  406d40:	49 8d b9 00 01 00 00 	lea    0x100(%r9),%rdi
    int put_cards_in_col_idx = 0;
  406d47:	45 31 db             	xor    %r11d,%r11d
  406d4a:	4d 89 c4             	mov    %r8,%r12
    char *const indirect_stacks_buffer =
  406d4d:	48 89 7c 24 48       	mov    %rdi,0x48(%rsp)
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406d52:	41 83 fb 08          	cmp    $0x8,%r11d
  406d56:	0f 84 34 03 00 00    	je     407090 <fc_solve_sfs_move_sequences_to_free_stacks+0xcd0>
        if (fcs_state_col_is_empty(state, ret))
  406d5c:	49 63 f3             	movslq %r11d,%rsi
  406d5f:	48 8b 34 f1          	mov    (%rcx,%rsi,8),%rsi
  406d63:	80 3e 00             	cmpb   $0x0,(%rsi)
  406d66:	0f 84 fd 03 00 00    	je     407169 <fc_solve_sfs_move_sequences_to_free_stacks+0xda9>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406d6c:	45 8d 4b 01          	lea    0x1(%r11),%r9d
  406d70:	41 83 f9 08          	cmp    $0x8,%r9d
  406d74:	0f 84 16 03 00 00    	je     407090 <fc_solve_sfs_move_sequences_to_free_stacks+0xcd0>
        if (fcs_state_col_is_empty(state, ret))
  406d7a:	4d 63 c1             	movslq %r9d,%r8
  406d7d:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  406d81:	80 3e 00             	cmpb   $0x0,(%rsi)
  406d84:	0f 84 37 02 00 00    	je     406fc1 <fc_solve_sfs_move_sequences_to_free_stacks+0xc01>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406d8a:	45 8d 4b 02          	lea    0x2(%r11),%r9d
  406d8e:	41 83 f9 08          	cmp    $0x8,%r9d
  406d92:	0f 84 f8 02 00 00    	je     407090 <fc_solve_sfs_move_sequences_to_free_stacks+0xcd0>
        if (fcs_state_col_is_empty(state, ret))
  406d98:	4d 63 c1             	movslq %r9d,%r8
  406d9b:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  406d9f:	80 3e 00             	cmpb   $0x0,(%rsi)
  406da2:	0f 84 19 02 00 00    	je     406fc1 <fc_solve_sfs_move_sequences_to_free_stacks+0xc01>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406da8:	45 8d 4b 03          	lea    0x3(%r11),%r9d
  406dac:	41 83 f9 08          	cmp    $0x8,%r9d
  406db0:	0f 84 da 02 00 00    	je     407090 <fc_solve_sfs_move_sequences_to_free_stacks+0xcd0>
        if (fcs_state_col_is_empty(state, ret))
  406db6:	4d 63 c1             	movslq %r9d,%r8
  406db9:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  406dbd:	80 3e 00             	cmpb   $0x0,(%rsi)
  406dc0:	0f 84 fb 01 00 00    	je     406fc1 <fc_solve_sfs_move_sequences_to_free_stacks+0xc01>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406dc6:	45 8d 4b 04          	lea    0x4(%r11),%r9d
  406dca:	41 83 f9 08          	cmp    $0x8,%r9d
  406dce:	0f 84 bc 02 00 00    	je     407090 <fc_solve_sfs_move_sequences_to_free_stacks+0xcd0>
        if (fcs_state_col_is_empty(state, ret))
  406dd4:	4d 63 c1             	movslq %r9d,%r8
  406dd7:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  406ddb:	80 3e 00             	cmpb   $0x0,(%rsi)
  406dde:	0f 84 dd 01 00 00    	je     406fc1 <fc_solve_sfs_move_sequences_to_free_stacks+0xc01>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406de4:	45 8d 4b 05          	lea    0x5(%r11),%r9d
  406de8:	41 83 f9 08          	cmp    $0x8,%r9d
  406dec:	0f 84 9e 02 00 00    	je     407090 <fc_solve_sfs_move_sequences_to_free_stacks+0xcd0>
        if (fcs_state_col_is_empty(state, ret))
  406df2:	4d 63 c1             	movslq %r9d,%r8
  406df5:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  406df9:	80 3e 00             	cmpb   $0x0,(%rsi)
  406dfc:	0f 84 bf 01 00 00    	je     406fc1 <fc_solve_sfs_move_sequences_to_free_stacks+0xc01>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406e02:	45 8d 4b 06          	lea    0x6(%r11),%r9d
  406e06:	41 83 f9 08          	cmp    $0x8,%r9d
  406e0a:	0f 84 80 02 00 00    	je     407090 <fc_solve_sfs_move_sequences_to_free_stacks+0xcd0>
        if (fcs_state_col_is_empty(state, ret))
  406e10:	4d 63 c1             	movslq %r9d,%r8
  406e13:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  406e17:	80 3e 00             	cmpb   $0x0,(%rsi)
  406e1a:	0f 84 a1 01 00 00    	je     406fc1 <fc_solve_sfs_move_sequences_to_free_stacks+0xc01>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406e20:	45 85 db             	test   %r11d,%r11d
  406e23:	0f 85 67 02 00 00    	jne    407090 <fc_solve_sfs_move_sequences_to_free_stacks+0xcd0>
        if (fcs_state_col_is_empty(state, ret))
  406e29:	48 8b 49 38          	mov    0x38(%rcx),%rcx
    return -1;
  406e2d:	41 b9 ff ff ff ff    	mov    $0xffffffff,%r9d
  406e33:	49 c7 c0 ff ff ff ff 	mov    $0xffffffffffffffff,%r8
        if (fcs_state_col_is_empty(state, ret))
  406e3a:	80 39 00             	cmpb   $0x0,(%rcx)
  406e3d:	0f 84 72 01 00 00    	je     406fb5 <fc_solve_sfs_move_sequences_to_free_stacks+0xbf5>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  406e43:	48 8b b4 24 98 00 00 	mov    0x98(%rsp),%rsi
  406e4a:	00 
  406e4b:	8b 4e 14             	mov    0x14(%rsi),%ecx
  406e4e:	44 0f a3 c9          	bt     %r9d,%ecx
  406e52:	0f 83 d8 01 00 00    	jae    407030 <fc_solve_sfs_move_sequences_to_free_stacks+0xc70>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  406e58:	4a 8b 34 e0          	mov    (%rax,%r12,8),%rsi
    fcs_col_pop_card(col, ret);
  406e5c:	0f be 3e             	movsbl (%rsi),%edi
  406e5f:	89 f9                	mov    %edi,%ecx
  406e61:	83 ef 01             	sub    $0x1,%edi
  406e64:	83 e9 01             	sub    $0x1,%ecx
  406e67:	48 63 ff             	movslq %edi,%rdi
        --(*col_num_cards);
  406e6a:	83 ea 01             	sub    $0x1,%edx
  406e6d:	0f b6 7c 3e 01       	movzbl 0x1(%rsi,%rdi,1),%edi
  406e72:	88 0e                	mov    %cl,(%rsi)
  406e74:	48 0f be c9          	movsbq %cl,%rcx
  406e78:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  406e7d:	4a 8b 34 c0          	mov    (%rax,%r8,8),%rsi
    fcs_col_push_card(col, card);
  406e81:	48 0f be 0e          	movsbq (%rsi),%rcx
  406e85:	44 8d 41 01          	lea    0x1(%rcx),%r8d
  406e89:	44 88 06             	mov    %r8b,(%rsi)
  406e8c:	40 88 7c 0e 01       	mov    %dil,0x1(%rsi,%rcx,1)
  406e91:	48 8b 8c 24 90 00 00 	mov    0x90(%rsp),%rcx
  406e98:	00 
  406e99:	89 94 24 a0 00 00 00 	mov    %edx,0xa0(%rsp)
        while ((*col_num_cards) == 0)
  406ea0:	0f 85 ac fe ff ff    	jne    406d52 <fc_solve_sfs_move_sequences_to_free_stacks+0x992>
                const int b = find_empty_stack(raw_state_raw,
  406ea6:	45 8d 41 01          	lea    0x1(%r9),%r8d
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406eaa:	41 83 f8 08          	cmp    $0x8,%r8d
  406eae:	0f 84 ab fa ff ff    	je     40695f <fc_solve_sfs_move_sequences_to_free_stacks+0x59f>
        if (fcs_state_col_is_empty(state, ret))
  406eb4:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  406eb9:	49 63 c0             	movslq %r8d,%rax
  406ebc:	48 8b 14 c2          	mov    (%rdx,%rax,8),%rdx
  406ec0:	80 3a 00             	cmpb   $0x0,(%rdx)
  406ec3:	0f 84 ec fb ff ff    	je     406ab5 <fc_solve_sfs_move_sequences_to_free_stacks+0x6f5>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406ec9:	45 8d 41 02          	lea    0x2(%r9),%r8d
  406ecd:	41 83 f8 08          	cmp    $0x8,%r8d
  406ed1:	0f 84 88 fa ff ff    	je     40695f <fc_solve_sfs_move_sequences_to_free_stacks+0x59f>
        if (fcs_state_col_is_empty(state, ret))
  406ed7:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  406edc:	49 63 c0             	movslq %r8d,%rax
  406edf:	48 8b 14 c7          	mov    (%rdi,%rax,8),%rdx
  406ee3:	80 3a 00             	cmpb   $0x0,(%rdx)
  406ee6:	0f 84 c9 fb ff ff    	je     406ab5 <fc_solve_sfs_move_sequences_to_free_stacks+0x6f5>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406eec:	45 8d 41 03          	lea    0x3(%r9),%r8d
  406ef0:	41 83 f8 08          	cmp    $0x8,%r8d
  406ef4:	0f 85 d9 f9 ff ff    	jne    4068d3 <fc_solve_sfs_move_sequences_to_free_stacks+0x513>
  406efa:	e9 60 fa ff ff       	jmpq   40695f <fc_solve_sfs_move_sequences_to_free_stacks+0x59f>
  406eff:	90                   	nop
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  406f00:	89 cf                	mov    %ecx,%edi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  406f02:	4a 8b 34 c0          	mov    (%rax,%r8,8),%rsi
            ++dest_fc_idx;
  406f06:	83 c7 01             	add    $0x1,%edi
    fcs_col_pop_card(col, ret);
  406f09:	44 0f be 1e          	movsbl (%rsi),%r11d
  406f0d:	44 89 d9             	mov    %r11d,%ecx
  406f10:	41 83 eb 01          	sub    $0x1,%r11d
  406f14:	4d 63 db             	movslq %r11d,%r11
  406f17:	83 e9 01             	sub    $0x1,%ecx
  406f1a:	46 0f b6 5c 1e 01    	movzbl 0x1(%rsi,%r11,1),%r11d
  406f20:	88 0e                	mov    %cl,(%rsi)
  406f22:	48 0f be c9          	movsbq %cl,%rcx
  406f26:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  406f2b:	46 88 5c 10 40       	mov    %r11b,0x40(%rax,%r10,1)
            while ((*col_num_cards) == 0)
  406f30:	83 ea 01             	sub    $0x1,%edx
  406f33:	75 2b                	jne    406f60 <fc_solve_sfs_move_sequences_to_free_stacks+0xba0>
  406f35:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406f3c:	00 
        if (fcs_state_col_is_empty(state, ret))
  406f3d:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  406f42:	48 89 c1             	mov    %rax,%rcx
  406f45:	48 8b 07             	mov    (%rdi),%rax
  406f48:	80 38 00             	cmpb   $0x0,(%rax)
  406f4b:	0f 85 6f f9 ff ff    	jne    4068c0 <fc_solve_sfs_move_sequences_to_free_stacks+0x500>
  406f51:	31 c0                	xor    %eax,%eax
                const int b = find_empty_stack(raw_state_raw,
  406f53:	45 31 c0             	xor    %r8d,%r8d
  406f56:	48 89 c2             	mov    %rax,%rdx
  406f59:	e9 0e fa ff ff       	jmpq   40696c <fc_solve_sfs_move_sequences_to_free_stacks+0x5ac>
  406f5e:	66 90                	xchg   %ax,%ax
  406f60:	be 01 00 00 00       	mov    $0x1,%esi
  406f65:	41 89 d4             	mov    %edx,%r12d
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  406f68:	83 ff 04             	cmp    $0x4,%edi
  406f6b:	0f 85 6f fd ff ff    	jne    406ce0 <fc_solve_sfs_move_sequences_to_free_stacks+0x920>
  406f71:	e9 ba fd ff ff       	jmpq   406d30 <fc_solve_sfs_move_sequences_to_free_stacks+0x970>
  406f76:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  406f7d:	00 00 00 
  406f80:	49 8b 84 24 f0 00 00 	mov    0xf0(%r12),%rax
  406f87:	00 
  406f88:	49 89 84 24 e8 00 00 	mov    %rax,0xe8(%r12)
  406f8f:	00 
  406f90:	e9 b5 fa ff ff       	jmpq   406a4a <fc_solve_sfs_move_sequences_to_free_stacks+0x68a>
  406f95:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  406f9c:	00 00 00 00 
  406fa0:	49 8b 84 24 f0 00 00 	mov    0xf0(%r12),%rax
  406fa7:	00 
  406fa8:	49 89 84 24 e8 00 00 	mov    %rax,0xe8(%r12)
  406faf:	00 
  406fb0:	e9 ff f7 ff ff       	jmpq   4067b4 <fc_solve_sfs_move_sequences_to_free_stacks+0x3f4>
        if (fcs_state_col_is_empty(state, ret))
  406fb5:	41 b9 07 00 00 00    	mov    $0x7,%r9d
  406fbb:	41 b8 07 00 00 00    	mov    $0x7,%r8d
  406fc1:	45 8d 59 01          	lea    0x1(%r9),%r11d
  406fc5:	e9 79 fe ff ff       	jmpq   406e43 <fc_solve_sfs_move_sequences_to_free_stacks+0xa83>
  406fca:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  406fd0:	bf 03 00 00 00       	mov    $0x3,%edi
  406fd5:	41 ba 03 00 00 00    	mov    $0x3,%r10d
  406fdb:	e9 22 ff ff ff       	jmpq   406f02 <fc_solve_sfs_move_sequences_to_free_stacks+0xb42>
                my_copy_stack(b);
  406fe0:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  406fe5:	49 89 7c 08 f8       	mov    %rdi,-0x8(%r8,%rcx,1)
  406fea:	48 83 e9 01          	sub    $0x1,%rcx
  406fee:	4c 89 c7             	mov    %r8,%rdi
  406ff1:	48 c1 e9 03          	shr    $0x3,%rcx
  406ff5:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  406ff8:	e9 1d fb ff ff       	jmpq   406b1a <fc_solve_sfs_move_sequences_to_free_stacks+0x75a>
  406ffd:	0f 1f 00             	nopl   (%rax)
                my_copy_stack(stack_idx);
  407000:	48 8b 44 16 f8       	mov    -0x8(%rsi,%rdx,1),%rax
  407005:	48 8d 4a ff          	lea    -0x1(%rdx),%rcx
  407009:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  40700e:	48 c1 e9 03          	shr    $0x3,%rcx
  407012:	48 89 44 17 f8       	mov    %rax,-0x8(%rdi,%rdx,1)
  407017:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40701a:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  407021:	00 
  407022:	e9 8d fb ff ff       	jmpq   406bb4 <fc_solve_sfs_move_sequences_to_free_stacks+0x7f4>
  407027:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40702e:	00 00 
  407030:	4a 8d 3c c0          	lea    (%rax,%r8,8),%rdi
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  407034:	44 0f ab c9          	bts    %r9d,%ecx
  407038:	45 89 ca             	mov    %r9d,%r10d
  40703b:	89 4e 14             	mov    %ecx,0x14(%rsi)
  40703e:	48 8b 37             	mov    (%rdi),%rsi
  407041:	41 c1 e2 07          	shl    $0x7,%r10d
  407045:	4d 63 d2             	movslq %r10d,%r10
  407048:	48 89 7c 24 40       	mov    %rdi,0x40(%rsp)
  40704d:	4c 03 54 24 48       	add    0x48(%rsp),%r10
  407052:	0f be 0e             	movsbl (%rsi),%ecx
  407055:	83 c1 01             	add    $0x1,%ecx
  407058:	48 63 c9             	movslq %ecx,%rcx
  40705b:	48 83 f9 08          	cmp    $0x8,%rcx
  40705f:	0f 83 ac 00 00 00    	jae    407111 <fc_solve_sfs_move_sequences_to_free_stacks+0xd51>
  407065:	f6 c1 04             	test   $0x4,%cl
  407068:	0f 85 b1 01 00 00    	jne    40721f <fc_solve_sfs_move_sequences_to_free_stacks+0xe5f>
  40706e:	48 85 c9             	test   %rcx,%rcx
  407071:	0f 85 c0 00 00 00    	jne    407137 <fc_solve_sfs_move_sequences_to_free_stacks+0xd77>
  407077:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  40707c:	4c 89 17             	mov    %r10,(%rdi)
  40707f:	e9 d4 fd ff ff       	jmpq   406e58 <fc_solve_sfs_move_sequences_to_free_stacks+0xa98>
  407084:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40708b:	00 00 00 00 
  40708f:	90                   	nop
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407090:	45 31 db             	xor    %r11d,%r11d
    return -1;
  407093:	41 b9 ff ff ff ff    	mov    $0xffffffff,%r9d
  407099:	49 c7 c0 ff ff ff ff 	mov    $0xffffffffffffffff,%r8
  4070a0:	e9 9e fd ff ff       	jmpq   406e43 <fc_solve_sfs_move_sequences_to_free_stacks+0xa83>
  4070a5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4070ac:	00 00 00 00 
                copy_two_stacks(stack_idx, ds);
  4070b0:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  4070b5:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  4070ba:	48 89 44 0f f8       	mov    %rax,-0x8(%rdi,%rcx,1)
  4070bf:	48 83 e9 01          	sub    $0x1,%rcx
  4070c3:	48 c1 e9 03          	shr    $0x3,%rcx
  4070c7:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4070ca:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4070d1:	00 
  4070d2:	e9 40 fb ff ff       	jmpq   406c17 <fc_solve_sfs_move_sequences_to_free_stacks+0x857>
  4070d7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4070de:	00 00 
  4070e0:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  4070e5:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  4070ea:	48 89 44 0f f8       	mov    %rax,-0x8(%rdi,%rcx,1)
  4070ef:	48 83 e9 01          	sub    $0x1,%rcx
  4070f3:	48 c1 e9 03          	shr    $0x3,%rcx
  4070f7:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4070fa:	e9 7d fb ff ff       	jmpq   406c7c <fc_solve_sfs_move_sequences_to_free_stacks+0x8bc>
        if (fcs_state_col_is_empty(state, ret))
  4070ff:	41 89 d0             	mov    %edx,%r8d
  407102:	48 89 c2             	mov    %rax,%rdx
  407105:	e9 62 f8 ff ff       	jmpq   40696c <fc_solve_sfs_move_sequences_to_free_stacks+0x5ac>
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  40710a:	31 ed                	xor    %ebp,%ebp
  40710c:	e9 25 f4 ff ff       	jmpq   406536 <fc_solve_sfs_move_sequences_to_free_stacks+0x176>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  407111:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  407116:	49 89 7c 0a f8       	mov    %rdi,-0x8(%r10,%rcx,1)
  40711b:	48 83 e9 01          	sub    $0x1,%rcx
  40711f:	4c 89 d7             	mov    %r10,%rdi
  407122:	48 c1 e9 03          	shr    $0x3,%rcx
  407126:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  407129:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  40712e:	4c 89 17             	mov    %r10,(%rdi)
  407131:	e9 22 fd ff ff       	jmpq   406e58 <fc_solve_sfs_move_sequences_to_free_stacks+0xa98>
  407136:	c3                   	retq   
  407137:	0f b6 3e             	movzbl (%rsi),%edi
  40713a:	41 88 3a             	mov    %dil,(%r10)
  40713d:	f6 c1 02             	test   $0x2,%cl
  407140:	0f 84 31 ff ff ff    	je     407077 <fc_solve_sfs_move_sequences_to_free_stacks+0xcb7>
  407146:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  40714b:	66 41 89 74 0a fe    	mov    %si,-0x2(%r10,%rcx,1)
  407151:	e9 21 ff ff ff       	jmpq   407077 <fc_solve_sfs_move_sequences_to_free_stacks+0xcb7>
  407156:	b8 01 00 00 00       	mov    $0x1,%eax
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40715b:	41 b8 01 00 00 00    	mov    $0x1,%r8d
  407161:	48 89 c2             	mov    %rax,%rdx
  407164:	e9 03 f8 ff ff       	jmpq   40696c <fc_solve_sfs_move_sequences_to_free_stacks+0x5ac>
        if (fcs_state_col_is_empty(state, ret))
  407169:	4d 63 c3             	movslq %r11d,%r8
  40716c:	41 83 c3 01          	add    $0x1,%r11d
  407170:	4d 89 c1             	mov    %r8,%r9
  407173:	e9 cb fc ff ff       	jmpq   406e43 <fc_solve_sfs_move_sequences_to_free_stacks+0xa83>
                my_copy_stack(b);
  407178:	8b 3e                	mov    (%rsi),%edi
  40717a:	41 89 38             	mov    %edi,(%r8)
  40717d:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  407181:	41 89 74 08 fc       	mov    %esi,-0x4(%r8,%rcx,1)
  407186:	e9 8f f9 ff ff       	jmpq   406b1a <fc_solve_sfs_move_sequences_to_free_stacks+0x75a>
                my_copy_stack(stack_idx);
  40718b:	8b 06                	mov    (%rsi),%eax
  40718d:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  407192:	89 07                	mov    %eax,(%rdi)
  407194:	8b 44 16 fc          	mov    -0x4(%rsi,%rdx,1),%eax
  407198:	89 44 17 fc          	mov    %eax,-0x4(%rdi,%rdx,1)
  40719c:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4071a3:	00 
  4071a4:	e9 0b fa ff ff       	jmpq   406bb4 <fc_solve_sfs_move_sequences_to_free_stacks+0x7f4>
                copy_two_stacks(stack_idx, ds);
  4071a9:	8b 06                	mov    (%rsi),%eax
  4071ab:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  4071b0:	89 07                	mov    %eax,(%rdi)
  4071b2:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  4071b6:	89 44 0f fc          	mov    %eax,-0x4(%rdi,%rcx,1)
  4071ba:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4071c1:	00 
  4071c2:	e9 50 fa ff ff       	jmpq   406c17 <fc_solve_sfs_move_sequences_to_free_stacks+0x857>
  4071c7:	8b 06                	mov    (%rsi),%eax
  4071c9:	48 8b 54 24 38       	mov    0x38(%rsp),%rdx
  4071ce:	89 02                	mov    %eax,(%rdx)
  4071d0:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  4071d4:	89 44 0a fc          	mov    %eax,-0x4(%rdx,%rcx,1)
  4071d8:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  4071df:	00 
  4071e0:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4071e7:	00 
  4071e8:	e9 9f fa ff ff       	jmpq   406c8c <fc_solve_sfs_move_sequences_to_free_stacks+0x8cc>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4071ed:	c7 44 24 68 04 00 00 	movl   $0x4,0x68(%rsp)
  4071f4:	00 
  4071f5:	8b 5c 24 68          	mov    0x68(%rsp),%ebx
  4071f9:	41 b9 01 00 00 00    	mov    $0x1,%r9d
  4071ff:	89 d8                	mov    %ebx,%eax
  407201:	89 d9                	mov    %ebx,%ecx
  407203:	c1 e0 07             	shl    $0x7,%eax
  407206:	41 d3 e1             	shl    %cl,%r9d
  407209:	48 98                	cltq   
  40720b:	44 89 4c 24 64       	mov    %r9d,0x64(%rsp)
  407210:	e9 67 f2 ff ff       	jmpq   40647c <fc_solve_sfs_move_sequences_to_free_stacks+0xbc>
  407215:	c7 44 24 68 00 00 00 	movl   $0x0,0x68(%rsp)
  40721c:	00 
  40721d:	eb d6                	jmp    4071f5 <fc_solve_sfs_move_sequences_to_free_stacks+0xe35>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  40721f:	8b 3e                	mov    (%rsi),%edi
  407221:	41 89 3a             	mov    %edi,(%r10)
  407224:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  407228:	41 89 74 0a fc       	mov    %esi,-0x4(%r10,%rcx,1)
  40722d:	e9 45 fe ff ff       	jmpq   407077 <fc_solve_sfs_move_sequences_to_free_stacks+0xcb7>
                my_copy_stack(stack_idx);
  407232:	0f b7 44 16 fe       	movzwl -0x2(%rsi,%rdx,1),%eax
  407237:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  40723c:	66 89 44 17 fe       	mov    %ax,-0x2(%rdi,%rdx,1)
  407241:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  407248:	00 
  407249:	e9 66 f9 ff ff       	jmpq   406bb4 <fc_solve_sfs_move_sequences_to_free_stacks+0x7f4>
                my_copy_stack(b);
  40724e:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  407253:	66 41 89 74 08 fe    	mov    %si,-0x2(%r8,%rcx,1)
  407259:	e9 bc f8 ff ff       	jmpq   406b1a <fc_solve_sfs_move_sequences_to_free_stacks+0x75a>
                copy_two_stacks(stack_idx, ds);
  40725e:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  407263:	48 8b 54 24 38       	mov    0x38(%rsp),%rdx
  407268:	66 89 44 0a fe       	mov    %ax,-0x2(%rdx,%rcx,1)
  40726d:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  407274:	00 
  407275:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  40727c:	00 
  40727d:	e9 0a fa ff ff       	jmpq   406c8c <fc_solve_sfs_move_sequences_to_free_stacks+0x8cc>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407282:	c7 44 24 68 02 00 00 	movl   $0x2,0x68(%rsp)
  407289:	00 
  40728a:	e9 66 ff ff ff       	jmpq   4071f5 <fc_solve_sfs_move_sequences_to_free_stacks+0xe35>
  40728f:	c7 44 24 68 01 00 00 	movl   $0x1,0x68(%rsp)
  407296:	00 
  407297:	e9 59 ff ff ff       	jmpq   4071f5 <fc_solve_sfs_move_sequences_to_free_stacks+0xe35>
  40729c:	c7 44 24 68 03 00 00 	movl   $0x3,0x68(%rsp)
  4072a3:	00 
  4072a4:	e9 4c ff ff ff       	jmpq   4071f5 <fc_solve_sfs_move_sequences_to_free_stacks+0xe35>
                copy_two_stacks(stack_idx, ds);
  4072a9:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  4072ae:	48 8b 7c 24 70       	mov    0x70(%rsp),%rdi
  4072b3:	66 89 44 0f fe       	mov    %ax,-0x2(%rdi,%rcx,1)
  4072b8:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4072bf:	00 
  4072c0:	e9 52 f9 ff ff       	jmpq   406c17 <fc_solve_sfs_move_sequences_to_free_stacks+0x857>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4072c5:	c7 44 24 68 07 00 00 	movl   $0x7,0x68(%rsp)
  4072cc:	00 
  4072cd:	e9 23 ff ff ff       	jmpq   4071f5 <fc_solve_sfs_move_sequences_to_free_stacks+0xe35>
  4072d2:	c7 44 24 68 05 00 00 	movl   $0x5,0x68(%rsp)
  4072d9:	00 
  4072da:	e9 16 ff ff ff       	jmpq   4071f5 <fc_solve_sfs_move_sequences_to_free_stacks+0xe35>
  4072df:	c7 44 24 68 06 00 00 	movl   $0x6,0x68(%rsp)
  4072e6:	00 
  4072e7:	e9 09 ff ff ff       	jmpq   4071f5 <fc_solve_sfs_move_sequences_to_free_stacks+0xe35>
  4072ec:	0f 1f 40 00          	nopl   0x0(%rax)

00000000004072f0 <fc_solve_sfs_move_stack_cards_to_different_stacks>:
{
  4072f0:	41 57                	push   %r15
  4072f2:	41 56                	push   %r14
  4072f4:	41 55                	push   %r13
  4072f6:	41 54                	push   %r12
  4072f8:	55                   	push   %rbp
  4072f9:	53                   	push   %rbx
  4072fa:	48 81 ec e8 00 00 00 	sub    $0xe8,%rsp
    MOVE_FUNCS__define_common();
  407301:	48 8b 1f             	mov    (%rdi),%rbx
    if (soft_thread->super_method_type == FCS_SUPER_METHOD_DFS)
  407304:	8b 47 20             	mov    0x20(%rdi),%eax
{
  407307:	48 89 7c 24 68       	mov    %rdi,0x68(%rsp)
  40730c:	48 89 74 24 28       	mov    %rsi,0x28(%rsp)
    const_SLOT(num_vacant_freecells, soft_thread);
  407311:	44 0f b6 b7 e4 01 00 	movzbl 0x1e4(%rdi),%r14d
  407318:	00 
{
  407319:	48 89 94 24 90 00 00 	mov    %rdx,0x90(%rsp)
  407320:	00 
    const_SLOT(num_vacant_stacks, soft_thread);
  407321:	44 0f b6 bf e3 01 00 	movzbl 0x1e3(%rdi),%r15d
  407328:	00 
    MOVE_FUNCS__define_common();
  407329:	48 89 9c 24 88 00 00 	mov    %rbx,0x88(%rsp)
  407330:	00 
  407331:	48 81 c3 00 01 00 00 	add    $0x100,%rbx
  407338:	48 89 9c 24 a0 00 00 	mov    %rbx,0xa0(%rsp)
  40733f:	00 
        return (BEFS_M_VAR(soft_thread, befs_positions_by_rank));
  407340:	48 8d 5f 60          	lea    0x60(%rdi),%rbx
{
  407344:	48 89 4c 24 58       	mov    %rcx,0x58(%rsp)
  407349:	48 89 5c 24 60       	mov    %rbx,0x60(%rsp)
    if (soft_thread->super_method_type == FCS_SUPER_METHOD_DFS)
  40734e:	85 c0                	test   %eax,%eax
  407350:	75 15                	jne    407367 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x77>
        return (DFS_VAR(soft_thread, soft_dfs_info)[DFS_VAR(soft_thread, depth)]
  407352:	48 69 47 38 b0 00 00 	imul   $0xb0,0x38(%rdi),%rax
  407359:	00 
  40735a:	48 03 47 30          	add    0x30(%rdi),%rax
  40735e:	48 83 c0 40          	add    $0x40,%rax
  407362:	48 89 44 24 60       	mov    %rax,0x60(%rsp)
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  407367:	48 8b 84 24 a0 00 00 	mov    0xa0(%rsp),%rax
  40736e:	00 
    int *col_num_cards = num_cards_to_move_from_columns;
  40736f:	45 89 f5             	mov    %r14d,%r13d
{
  407372:	48 c7 44 24 10 00 00 	movq   $0x0,0x10(%rsp)
  407379:	00 00 
    int *col_num_cards = num_cards_to_move_from_columns;
  40737b:	44 88 bc 24 83 00 00 	mov    %r15b,0x83(%rsp)
  407382:	00 
  407383:	48 89 84 24 98 00 00 	mov    %rax,0x98(%rsp)
  40738a:	00 
  40738b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  407390:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
    ret.col = fcs_state_get_col(*s, stack_idx);
  407395:	48 8b 5c 24 28       	mov    0x28(%rsp),%rbx
  40739a:	89 44 24 7c          	mov    %eax,0x7c(%rsp)
  40739e:	4c 8b 24 c3          	mov    (%rbx,%rax,8),%r12
    ret.col_len_minus_1 = (ret.col_len = fcs_col_len(ret.col)) - 1;
  4073a2:	49 0f be 04 24       	movsbq (%r12),%rax
  4073a7:	48 8d 70 ff          	lea    -0x1(%rax),%rsi
  4073ab:	48 89 44 24 40       	mov    %rax,0x40(%rsp)
  4073b0:	48 89 74 24 48       	mov    %rsi,0x48(%rsp)
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4073b5:	48 85 f6             	test   %rsi,%rsi
  4073b8:	0f 8e cb 08 00 00    	jle    407c89 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x999>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  4073be:	49 0f be 44 24 01    	movsbq 0x1(%r12),%rax
  4073c4:	49 0f be 54 24 02    	movsbq 0x2(%r12),%rdx
  4073ca:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  4073ce:	80 bc 02 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rdx,%rax,1)
  4073d5:	00 
  4073d6:	0f 84 ad 08 00 00    	je     407c89 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x999>
  4073dc:	b8 01 00 00 00       	mov    $0x1,%eax
  4073e1:	eb 2b                	jmp    40740e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x11e>
  4073e3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4073ea:	00 00 00 00 
  4073ee:	66 90                	xchg   %ax,%ax
  4073f0:	49 0f be 54 04 01    	movsbq 0x1(%r12,%rax,1),%rdx
  4073f6:	49 0f be 4c 04 02    	movsbq 0x2(%r12,%rax,1),%rcx
  4073fc:	48 83 c0 01          	add    $0x1,%rax
  407400:	48 c1 e2 06          	shl    $0x6,%rdx
  407404:	80 bc 11 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rcx,%rdx,1)
  40740b:	00 
  40740c:	74 08                	je     407416 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x126>
         ++((*iter).seq_end))
  40740e:	49 89 c6             	mov    %rax,%r14
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  407411:	48 39 c6             	cmp    %rax,%rsi
  407414:	75 da                	jne    4073f0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x100>
    return ret;
  407416:	0f b6 4c 24 7c       	movzbl 0x7c(%rsp),%ecx
  40741b:	b8 01 00 00 00       	mov    $0x1,%eax
  407420:	d3 e0                	shl    %cl,%eax
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  407422:	48 83 7c 24 40 00    	cmpq   $0x0,0x40(%rsp)
  407428:	89 84 24 84 00 00 00 	mov    %eax,0x84(%rsp)
  40742f:	0f 8e 67 05 00 00    	jle    40799c <fc_solve_sfs_move_stack_cards_to_different_stacks+0x6ac>
    return ret;
  407435:	48 c7 44 24 20 00 00 	movq   $0x0,0x20(%rsp)
  40743c:	00 00 
                sfs_check_state_begin();
  40743e:	4d 89 f7             	mov    %r14,%r15
  407441:	4c 89 e5             	mov    %r12,%rbp
  407444:	44 88 6c 24 7b       	mov    %r13b,0x7b(%rsp)
  407449:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            const int col_num_cards = iter.col_len_minus_1 - iter.seq_end;
  407450:	8b 44 24 48          	mov    0x48(%rsp),%eax
  407454:	44 29 f8             	sub    %r15d,%eax
  407457:	89 44 24 1c          	mov    %eax,0x1c(%rsp)
    return fc_solve_is_king_buf[(size_t)card];
  40745b:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  407460:	48 0f be 44 05 01    	movsbq 0x1(%rbp,%rax,1),%rax
            if (unlikely(fcs_card_is_king(card)))
  407466:	80 b8 00 02 41 00 00 	cmpb   $0x0,0x410200(%rax)
  40746d:	0f 85 a6 04 00 00    	jne    407919 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x629>
            FCS_POS_IDX_TO_CHECK_START_LOOP(card)
  407473:	48 c1 e0 04          	shl    $0x4,%rax
  407477:	48 8b 5c 24 60       	mov    0x60(%rsp),%rbx
  40747c:	4c 8b 90 40 02 41 00 	mov    0x410240(%rax),%r10
  407483:	49 01 da             	add    %rbx,%r10
  407486:	48 03 98 48 02 41 00 	add    0x410248(%rax),%rbx
  40748d:	48 89 5c 24 08       	mov    %rbx,0x8(%rsp)
  407492:	49 39 da             	cmp    %rbx,%r10
  407495:	0f 83 7e 04 00 00    	jae    407919 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x629>
    const int *col_idx = cols_indexes;
  40749b:	44 0f b6 64 24 7b    	movzbl 0x7b(%rsp),%r12d
  4074a1:	4c 89 7c 24 30       	mov    %r15,0x30(%rsp)
  4074a6:	4c 89 d3             	mov    %r10,%rbx
  4074a9:	44 0f b6 ac 24 83 00 	movzbl 0x83(%rsp),%r13d
  4074b0:	00 00 
  4074b2:	48 89 6c 24 50       	mov    %rbp,0x50(%rsp)
  4074b7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4074be:	00 00 
                const int_fast32_t ds = pos_idx_to_check[0];
  4074c0:	48 0f be 2b          	movsbq (%rbx),%rbp
                if ((ds < 0) || (ds == stack_idx))
  4074c4:	48 85 ed             	test   %rbp,%rbp
  4074c7:	0f 88 33 04 00 00    	js     407900 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x610>
  4074cd:	44 0f be fd          	movsbl %bpl,%r15d
  4074d1:	44 3b 7c 24 10       	cmp    0x10(%rsp),%r15d
  4074d6:	0f 84 24 04 00 00    	je     407900 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x610>
                    fcs_state_col_len(state, ds) - dc - 1;
  4074dc:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
    const fcs_game_limit freecells_to_fill =
  4074e1:	44 89 e1             	mov    %r12d,%ecx
                    fcs_state_col_len(state, ds) - dc - 1;
  4074e4:	48 8b 04 e8          	mov    (%rax,%rbp,8),%rax
  4074e8:	44 0f be 30          	movsbl (%rax),%r14d
  4074ec:	0f be 43 01          	movsbl 0x1(%rbx),%eax
  4074f0:	f7 d0                	not    %eax
  4074f2:	41 01 c6             	add    %eax,%r14d
                if (!unlikely(
  4074f5:	0f b6 44 24 1c       	movzbl 0x1c(%rsp),%eax
  4074fa:	41 8d 14 06          	lea    (%r14,%rax,1),%edx
    const fcs_game_limit freecells_to_fill =
  4074fe:	44 38 e2             	cmp    %r12b,%dl
  407501:	0f 46 ca             	cmovbe %edx,%ecx
    num_cards_to_relocate -= freecells_to_fill;
  407504:	29 ca                	sub    %ecx,%edx
    return ((num_cards_to_relocate == 0) &&
  407506:	41 38 d5             	cmp    %dl,%r13b
  407509:	0f 82 f1 03 00 00    	jb     407900 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x610>
            (calc_max_sequence_move(
  40750f:	0f b6 c9             	movzbl %cl,%ecx
                if (!unlikely(
  407512:	41 0f b6 c4          	movzbl %r12b,%eax
                iter->seq_end - iter->c + 1));
  407516:	48 8b 7c 24 30       	mov    0x30(%rsp),%rdi
            (calc_max_sequence_move(
  40751b:	29 c8                	sub    %ecx,%eax
                iter->seq_end - iter->c + 1));
  40751d:	48 2b 7c 24 20       	sub    0x20(%rsp),%rdi
            (calc_max_sequence_move(
  407522:	44 89 e9             	mov    %r13d,%ecx
  407525:	83 c0 01             	add    $0x1,%eax
    const fcs_game_limit freestacks_to_fill =
  407528:	41 38 d5             	cmp    %dl,%r13b
  40752b:	41 0f 46 d5          	cmovbe %r13d,%edx
            (calc_max_sequence_move(
  40752f:	29 d1                	sub    %edx,%ecx
                iter->seq_end - iter->c + 1));
  407531:	48 89 7c 24 38       	mov    %rdi,0x38(%rsp)
            (calc_max_sequence_move(
  407536:	d3 e0                	shl    %cl,%eax
  407538:	48 98                	cltq   
    return ((num_cards_to_relocate == 0) &&
  40753a:	48 39 c7             	cmp    %rax,%rdi
  40753d:	0f 8d bd 03 00 00    	jge    407900 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x610>
                sfs_check_state_begin();
  407543:	48 8b 54 24 28       	mov    0x28(%rsp),%rdx
  407548:	48 8d b4 24 c0 00 00 	lea    0xc0(%rsp),%rsi
  40754f:	00 
  407550:	40 88 6c 24 70       	mov    %bpl,0x70(%rsp)
  407555:	48 8b 8c 24 90 00 00 	mov    0x90(%rsp),%rcx
  40755c:	00 
  40755d:	48 8b bc 24 88 00 00 	mov    0x88(%rsp),%rdi
  407564:	00 
  407565:	e8 b6 a4 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
                copy_two_stacks(stack_idx, ds);
  40756a:	48 8b 94 24 c8 00 00 	mov    0xc8(%rsp),%rdx
  407571:	00 
  407572:	44 0f b6 44 24 70    	movzbl 0x70(%rsp),%r8d
  407578:	8b 42 14             	mov    0x14(%rdx),%eax
  40757b:	85 84 24 84 00 00 00 	test   %eax,0x84(%rsp)
  407582:	0f 84 28 05 00 00    	je     407ab0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x7c0>
  407588:	4c 8b 94 24 c0 00 00 	mov    0xc0(%rsp),%r10
  40758f:	00 
  407590:	44 0f a3 c0          	bt     %r8d,%eax
  407594:	0f 83 86 04 00 00    	jae    407a20 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x730>
                empty_two_cols_from_new_state(soft_thread,
  40759a:	48 8b 7c 24 68       	mov    0x68(%rsp),%rdi
                const int cols_indexes[3] = {ds, stack_idx, -1};
  40759f:	44 89 bc 24 b4 00 00 	mov    %r15d,0xb4(%rsp)
  4075a6:	00 
                const int dest_cards_num =
  4075a7:	44 89 f0             	mov    %r14d,%eax
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  4075aa:	8b 74 24 1c          	mov    0x1c(%rsp),%esi
  4075ae:	44 89 b4 24 d0 00 00 	mov    %r14d,0xd0(%rsp)
  4075b5:	00 
    int *col_num_cards = num_cards_to_move_from_columns;
  4075b6:	48 8d 94 24 d0 00 00 	lea    0xd0(%rsp),%rdx
  4075bd:	00 
                const int cols_indexes[3] = {ds, stack_idx, -1};
  4075be:	44 8b 4c 24 7c       	mov    0x7c(%rsp),%r9d
    const int *col_idx = cols_indexes;
  4075c3:	4c 8d 84 24 b4 00 00 	lea    0xb4(%rsp),%r8
  4075ca:	00 
                const int cols_indexes[3] = {ds, stack_idx, -1};
  4075cb:	c7 84 24 bc 00 00 00 	movl   $0xffffffff,0xbc(%rsp)
  4075d2:	ff ff ff ff 
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  4075d6:	c7 84 24 d8 00 00 00 	movl   $0xffffffff,0xd8(%rsp)
  4075dd:	ff ff ff ff 
                empty_two_cols_from_new_state(soft_thread,
  4075e1:	4c 8b 3f             	mov    (%rdi),%r15
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  4075e4:	89 b4 24 d4 00 00 00 	mov    %esi,0xd4(%rsp)
        int dest_fc_idx = 0;
  4075eb:	31 f6                	xor    %esi,%esi
                const int cols_indexes[3] = {ds, stack_idx, -1};
  4075ed:	44 89 8c 24 b8 00 00 	mov    %r9d,0xb8(%rsp)
  4075f4:	00 
  4075f5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4075fc:	00 00 00 00 
            while ((*col_num_cards) == 0)
  407600:	85 c0                	test   %eax,%eax
  407602:	75 1d                	jne    407621 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x331>
                if (*(++col_idx) == -1)
  407604:	41 83 f9 ff          	cmp    $0xffffffff,%r9d
  407608:	0f 84 f2 01 00 00    	je     407800 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x510>
  40760e:	8b 42 04             	mov    0x4(%rdx),%eax
  407611:	49 83 c0 04          	add    $0x4,%r8
                ++col_num_cards;
  407615:	48 83 c2 04          	add    $0x4,%rdx
  407619:	45 8b 48 04          	mov    0x4(%r8),%r9d
            while ((*col_num_cards) == 0)
  40761d:	85 c0                	test   %eax,%eax
  40761f:	74 e3                	je     407604 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x314>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  407621:	83 fe 04             	cmp    $0x4,%esi
  407624:	74 4c                	je     407672 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x382>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  407626:	48 63 fe             	movslq %esi,%rdi
  407629:	41 80 7c 3a 40 00    	cmpb   $0x0,0x40(%r10,%rdi,1)
  40762f:	0f 84 9d 03 00 00    	je     4079d2 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x6e2>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  407635:	8d 4e 01             	lea    0x1(%rsi),%ecx
  407638:	83 f9 04             	cmp    $0x4,%ecx
  40763b:	74 35                	je     407672 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x382>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  40763d:	48 63 f9             	movslq %ecx,%rdi
  407640:	41 80 7c 3a 40 00    	cmpb   $0x0,0x40(%r10,%rdi,1)
  407646:	0f 84 84 03 00 00    	je     4079d0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x6e0>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  40764c:	8d 4e 02             	lea    0x2(%rsi),%ecx
  40764f:	83 f9 04             	cmp    $0x4,%ecx
  407652:	74 1e                	je     407672 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x382>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  407654:	48 63 f9             	movslq %ecx,%rdi
  407657:	41 80 7c 3a 40 00    	cmpb   $0x0,0x40(%r10,%rdi,1)
  40765d:	0f 84 6d 03 00 00    	je     4079d0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x6e0>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  407663:	85 f6                	test   %esi,%esi
  407665:	75 0b                	jne    407672 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x382>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  407667:	41 80 7a 43 00       	cmpb   $0x0,0x43(%r10)
  40766c:	0f 84 56 05 00 00    	je     407bc8 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x8d8>
  407672:	48 8b 8c 24 c0 00 00 	mov    0xc0(%rsp),%rcx
  407679:	00 
    char *const indirect_stacks_buffer =
  40767a:	49 8d b7 00 01 00 00 	lea    0x100(%r15),%rsi
    int put_cards_in_col_idx = 0;
  407681:	45 31 db             	xor    %r11d,%r11d
  407684:	49 89 de             	mov    %rbx,%r14
    char *const indirect_stacks_buffer =
  407687:	48 89 74 24 70       	mov    %rsi,0x70(%rsp)
        while ((*col_num_cards) == 0)
  40768c:	85 c0                	test   %eax,%eax
  40768e:	75 1d                	jne    4076ad <fc_solve_sfs_move_stack_cards_to_different_stacks+0x3bd>
            if (*(++col_idx) == -1)
  407690:	41 83 f9 ff          	cmp    $0xffffffff,%r9d
  407694:	0f 84 98 05 00 00    	je     407c32 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x942>
  40769a:	8b 42 04             	mov    0x4(%rdx),%eax
  40769d:	49 83 c0 04          	add    $0x4,%r8
            ++col_num_cards;
  4076a1:	48 83 c2 04          	add    $0x4,%rdx
  4076a5:	45 8b 48 04          	mov    0x4(%r8),%r9d
        while ((*col_num_cards) == 0)
  4076a9:	85 c0                	test   %eax,%eax
  4076ab:	74 e3                	je     407690 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x3a0>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4076ad:	41 83 fb 08          	cmp    $0x8,%r11d
  4076b1:	0f 84 67 05 00 00    	je     407c1e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x92e>
        if (fcs_state_col_is_empty(state, ret))
  4076b7:	49 63 f3             	movslq %r11d,%rsi
  4076ba:	48 8b 34 f1          	mov    (%rcx,%rsi,8),%rsi
  4076be:	80 3e 00             	cmpb   $0x0,(%rsi)
  4076c1:	0f 84 ca 05 00 00    	je     407c91 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9a1>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4076c7:	41 8d 7b 01          	lea    0x1(%r11),%edi
  4076cb:	83 ff 08             	cmp    $0x8,%edi
  4076ce:	0f 84 4a 05 00 00    	je     407c1e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x92e>
        if (fcs_state_col_is_empty(state, ret))
  4076d4:	48 63 df             	movslq %edi,%rbx
  4076d7:	48 8b 34 d9          	mov    (%rcx,%rbx,8),%rsi
  4076db:	80 3e 00             	cmpb   $0x0,(%rsi)
  4076de:	0f 84 69 04 00 00    	je     407b4d <fc_solve_sfs_move_stack_cards_to_different_stacks+0x85d>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4076e4:	41 8d 7b 02          	lea    0x2(%r11),%edi
  4076e8:	83 ff 08             	cmp    $0x8,%edi
  4076eb:	0f 84 2d 05 00 00    	je     407c1e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x92e>
        if (fcs_state_col_is_empty(state, ret))
  4076f1:	48 63 df             	movslq %edi,%rbx
  4076f4:	48 8b 34 d9          	mov    (%rcx,%rbx,8),%rsi
  4076f8:	80 3e 00             	cmpb   $0x0,(%rsi)
  4076fb:	0f 84 4c 04 00 00    	je     407b4d <fc_solve_sfs_move_stack_cards_to_different_stacks+0x85d>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407701:	41 8d 7b 03          	lea    0x3(%r11),%edi
  407705:	83 ff 08             	cmp    $0x8,%edi
  407708:	0f 84 10 05 00 00    	je     407c1e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x92e>
        if (fcs_state_col_is_empty(state, ret))
  40770e:	48 63 df             	movslq %edi,%rbx
  407711:	48 8b 34 d9          	mov    (%rcx,%rbx,8),%rsi
  407715:	80 3e 00             	cmpb   $0x0,(%rsi)
  407718:	0f 84 2f 04 00 00    	je     407b4d <fc_solve_sfs_move_stack_cards_to_different_stacks+0x85d>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40771e:	41 8d 7b 04          	lea    0x4(%r11),%edi
  407722:	83 ff 08             	cmp    $0x8,%edi
  407725:	0f 84 f3 04 00 00    	je     407c1e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x92e>
        if (fcs_state_col_is_empty(state, ret))
  40772b:	48 63 df             	movslq %edi,%rbx
  40772e:	48 8b 34 d9          	mov    (%rcx,%rbx,8),%rsi
  407732:	80 3e 00             	cmpb   $0x0,(%rsi)
  407735:	0f 84 12 04 00 00    	je     407b4d <fc_solve_sfs_move_stack_cards_to_different_stacks+0x85d>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40773b:	41 8d 7b 05          	lea    0x5(%r11),%edi
  40773f:	83 ff 08             	cmp    $0x8,%edi
  407742:	0f 84 d6 04 00 00    	je     407c1e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x92e>
        if (fcs_state_col_is_empty(state, ret))
  407748:	48 63 df             	movslq %edi,%rbx
  40774b:	48 8b 34 d9          	mov    (%rcx,%rbx,8),%rsi
  40774f:	80 3e 00             	cmpb   $0x0,(%rsi)
  407752:	0f 84 f5 03 00 00    	je     407b4d <fc_solve_sfs_move_stack_cards_to_different_stacks+0x85d>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407758:	41 8d 7b 06          	lea    0x6(%r11),%edi
  40775c:	83 ff 08             	cmp    $0x8,%edi
  40775f:	0f 84 b9 04 00 00    	je     407c1e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x92e>
        if (fcs_state_col_is_empty(state, ret))
  407765:	48 63 df             	movslq %edi,%rbx
  407768:	48 8b 34 d9          	mov    (%rcx,%rbx,8),%rsi
  40776c:	80 3e 00             	cmpb   $0x0,(%rsi)
  40776f:	0f 84 d8 03 00 00    	je     407b4d <fc_solve_sfs_move_stack_cards_to_different_stacks+0x85d>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407775:	45 85 db             	test   %r11d,%r11d
  407778:	0f 85 a0 04 00 00    	jne    407c1e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x92e>
        if (fcs_state_col_is_empty(state, ret))
  40777e:	48 8b 49 38          	mov    0x38(%rcx),%rcx
    return -1;
  407782:	bf ff ff ff ff       	mov    $0xffffffff,%edi
  407787:	48 c7 c3 ff ff ff ff 	mov    $0xffffffffffffffff,%rbx
        if (fcs_state_col_is_empty(state, ret))
  40778e:	80 39 00             	cmpb   $0x0,(%rcx)
  407791:	0f 84 ac 03 00 00    	je     407b43 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x853>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  407797:	48 8b b4 24 c8 00 00 	mov    0xc8(%rsp),%rsi
  40779e:	00 
  40779f:	8b 4e 14             	mov    0x14(%rsi),%ecx
  4077a2:	0f a3 f9             	bt     %edi,%ecx
  4077a5:	0f 83 ba 03 00 00    	jae    407b65 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x875>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  4077ab:	49 63 08             	movslq (%r8),%rcx
        --(*col_num_cards);
  4077ae:	83 e8 01             	sub    $0x1,%eax
  4077b1:	89 02                	mov    %eax,(%rdx)
  4077b3:	49 8b 34 ca          	mov    (%r10,%rcx,8),%rsi
    fcs_col_pop_card(col, ret);
  4077b7:	0f be 3e             	movsbl (%rsi),%edi
  4077ba:	89 f9                	mov    %edi,%ecx
  4077bc:	83 ef 01             	sub    $0x1,%edi
  4077bf:	83 e9 01             	sub    $0x1,%ecx
  4077c2:	48 63 ff             	movslq %edi,%rdi
  4077c5:	0f b6 7c 3e 01       	movzbl 0x1(%rsi,%rdi,1),%edi
  4077ca:	88 0e                	mov    %cl,(%rsi)
  4077cc:	48 0f be c9          	movsbq %cl,%rcx
  4077d0:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  4077d5:	49 8b 34 da          	mov    (%r10,%rbx,8),%rsi
    fcs_col_push_card(col, card);
  4077d9:	48 0f be 0e          	movsbq (%rsi),%rcx
  4077dd:	8d 59 01             	lea    0x1(%rcx),%ebx
  4077e0:	88 1e                	mov    %bl,(%rsi)
  4077e2:	40 88 7c 0e 01       	mov    %dil,0x1(%rsi,%rcx,1)
        ++put_cards_in_col_idx;
  4077e7:	48 8b 8c 24 c0 00 00 	mov    0xc0(%rsp),%rcx
  4077ee:	00 
  4077ef:	e9 98 fe ff ff       	jmpq   40768c <fc_solve_sfs_move_stack_cards_to_different_stacks+0x39c>
  4077f4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4077fb:	00 00 00 00 
  4077ff:	90                   	nop
  407800:	48 8b 8c 24 c0 00 00 	mov    0xc0(%rsp),%rcx
  407807:	00 
  407808:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
                fcs_move_sequence(ds, stack_idx, iter.seq_end - iter.c + 1);
  40780d:	4c 8b 74 24 38       	mov    0x38(%rsp),%r14
  407812:	48 8b 2c e9          	mov    (%rcx,%rbp,8),%rbp
  407816:	48 8b 14 c1          	mov    (%rcx,%rax,8),%rdx
  40781a:	49 83 c6 01          	add    $0x1,%r14
    const size_t cards_size = (((size_t)cards_num) * sizeof(fcs_card));
  40781e:	49 63 ce             	movslq %r14d,%rcx
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  407821:	48 89 4c 24 38       	mov    %rcx,0x38(%rsp)
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  407826:	0f b6 02             	movzbl (%rdx),%eax
  407829:	44 29 f0             	sub    %r14d,%eax
  40782c:	88 02                	mov    %al,(%rdx)
  40782e:	48 0f be c0          	movsbq %al,%rax
    fcs_card *const src_cards_ptr =
  407832:	4c 8d 7c 02 01       	lea    0x1(%rdx,%rax,1),%r15
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  407837:	48 0f be 45 00       	movsbq 0x0(%rbp),%rax
  40783c:	48 89 ca             	mov    %rcx,%rdx
  40783f:	4c 89 fe             	mov    %r15,%rsi
  407842:	48 8d 7c 05 01       	lea    0x1(%rbp,%rax,1),%rdi
  407847:	e8 94 98 ff ff       	callq  4010e0 <memcpy@plt>
    memset(src_cards_ptr, 0, cards_size);
  40784c:	48 8b 4c 24 38       	mov    0x38(%rsp),%rcx
  407851:	31 f6                	xor    %esi,%esi
  407853:	4c 89 ff             	mov    %r15,%rdi
    fcs_col_len(dest_col) += cards_num;
  407856:	44 00 75 00          	add    %r14b,0x0(%rbp)
    memset(src_cards_ptr, 0, cards_size);
  40785a:	48 89 ca             	mov    %rcx,%rdx
  40785d:	e8 3e 98 ff ff       	callq  4010a0 <memset@plt>
    const_SLOT(hard_thread, soft_thread);
  407862:	48 8b 44 24 68       	mov    0x68(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  407867:	48 8d 94 24 d0 00 00 	lea    0xd0(%rsp),%rdx
  40786e:	00 
  40786f:	48 8d b4 24 c0 00 00 	lea    0xc0(%rsp),%rsi
  407876:	00 
    const_SLOT(hard_thread, soft_thread);
  407877:	48 8b 28             	mov    (%rax),%rbp
    if (!fc_solve_check_and_add_state(
  40787a:	48 89 ef             	mov    %rbp,%rdi
  40787d:	e8 ee a2 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  407882:	84 c0                	test   %al,%al
  407884:	0f 85 86 01 00 00    	jne    407a10 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x720>
        if (HT_FIELD(hard_thread, allocated_from_list))
  40788a:	80 bd 18 05 00 00 00 	cmpb   $0x0,0x518(%rbp)
  407891:	0f 84 99 02 00 00    	je     407b30 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x840>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  407897:	48 8b 95 b0 00 00 00 	mov    0xb0(%rbp),%rdx
  40789e:	48 8b 84 24 c8 00 00 	mov    0xc8(%rsp),%rax
  4078a5:	00 
  4078a6:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  4078a9:	48 8b 84 24 c0 00 00 	mov    0xc0(%rsp),%rax
  4078b0:	00 
  4078b1:	48 89 85 b0 00 00 00 	mov    %rax,0xb0(%rbp)
        return FCS_STATE_kv_to_collectible(&existing_state);
  4078b8:	48 8b ac 24 d0 00 00 	mov    0xd0(%rsp),%rbp
  4078bf:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  4078c0:	48 8b 44 24 58       	mov    0x58(%rsp),%rax
  4078c5:	31 c9                	xor    %ecx,%ecx
  4078c7:	48 8b 10             	mov    (%rax),%rdx
  4078ca:	48 8b 40 08          	mov    0x8(%rax),%rax
  4078ce:	48 85 c0             	test   %rax,%rax
  4078d1:	0f 95 c1             	setne  %cl
  4078d4:	48 01 d1             	add    %rdx,%rcx
  4078d7:	f6 c1 0f             	test   $0xf,%cl
  4078da:	0f 84 a0 01 00 00    	je     407a80 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x790>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  4078e0:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  4078e5:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  4078e9:	48 c1 e2 04          	shl    $0x4,%rdx
  4078ed:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4078f1:	48 01 d0             	add    %rdx,%rax
  4078f4:	48 89 0f             	mov    %rcx,(%rdi)
  4078f7:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4078fb:	48 89 28             	mov    %rbp,(%rax)
  4078fe:	66 90                	xchg   %ax,%ax
            FCS_POS_IDX_TO_CHECK_START_LOOP(card)
  407900:	48 83 c3 04          	add    $0x4,%rbx
  407904:	48 39 5c 24 08       	cmp    %rbx,0x8(%rsp)
  407909:	0f 87 b1 fb ff ff    	ja     4074c0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x1d0>
  40790f:	4c 8b 7c 24 30       	mov    0x30(%rsp),%r15
  407914:	48 8b 6c 24 50       	mov    0x50(%rsp),%rbp
    iter->c = iter->seq_end + 1;
  407919:	49 8d 47 01          	lea    0x1(%r15),%rax
  40791d:	48 89 44 24 20       	mov    %rax,0x20(%rsp)
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  407922:	48 39 44 24 48       	cmp    %rax,0x48(%rsp)
  407927:	0f 8e 0d 03 00 00    	jle    407c3a <fc_solve_sfs_move_stack_cards_to_different_stacks+0x94a>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40792d:	4a 0f be 44 3d 02    	movsbq 0x2(%rbp,%r15,1),%rax
  407933:	4a 0f be 54 3d 03    	movsbq 0x3(%rbp,%r15,1),%rdx
  407939:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  40793d:	80 bc 02 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rdx,%rax,1)
  407944:	00 
  407945:	0f 84 07 03 00 00    	je     407c52 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x962>
  40794b:	48 8b 74 24 40       	mov    0x40(%rsp),%rsi
  407950:	49 8d 47 02          	lea    0x2(%r15),%rax
  407954:	48 83 ee 01          	sub    $0x1,%rsi
  407958:	eb 24                	jmp    40797e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x68e>
  40795a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  407960:	48 0f be 54 05 01    	movsbq 0x1(%rbp,%rax,1),%rdx
  407966:	48 0f be 4c 05 02    	movsbq 0x2(%rbp,%rax,1),%rcx
  40796c:	48 83 c0 01          	add    $0x1,%rax
  407970:	48 c1 e2 06          	shl    $0x6,%rdx
  407974:	80 bc 11 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rcx,%rdx,1)
  40797b:	00 
  40797c:	74 08                	je     407986 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x696>
         ++((*iter).seq_end))
  40797e:	49 89 c7             	mov    %rax,%r15
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  407981:	48 39 f0             	cmp    %rsi,%rax
  407984:	75 da                	jne    407960 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x670>
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  407986:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  40798b:	48 39 74 24 40       	cmp    %rsi,0x40(%rsp)
  407990:	0f 8f ba fa ff ff    	jg     407450 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x160>
  407996:	44 0f b6 6c 24 7b    	movzbl 0x7b(%rsp),%r13d
  40799c:	48 83 44 24 10 01    	addq   $0x1,0x10(%rsp)
  4079a2:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
  4079a7:	48 83 ac 24 98 00 00 	subq   $0xffffffffffffff80,0x98(%rsp)
  4079ae:	00 80 
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  4079b0:	48 83 f8 08          	cmp    $0x8,%rax
  4079b4:	0f 85 d6 f9 ff ff    	jne    407390 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa0>
}
  4079ba:	48 81 c4 e8 00 00 00 	add    $0xe8,%rsp
  4079c1:	5b                   	pop    %rbx
  4079c2:	5d                   	pop    %rbp
  4079c3:	41 5c                	pop    %r12
  4079c5:	41 5d                	pop    %r13
  4079c7:	41 5e                	pop    %r14
  4079c9:	41 5f                	pop    %r15
  4079cb:	c3                   	retq   
  4079cc:	0f 1f 40 00          	nopl   0x0(%rax)
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4079d0:	89 ce                	mov    %ecx,%esi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  4079d2:	49 63 08             	movslq (%r8),%rcx
            --(*col_num_cards);
  4079d5:	83 e8 01             	sub    $0x1,%eax
            ++dest_fc_idx;
  4079d8:	83 c6 01             	add    $0x1,%esi
            --(*col_num_cards);
  4079db:	89 02                	mov    %eax,(%rdx)
  4079dd:	4d 8b 1c ca          	mov    (%r10,%rcx,8),%r11
    fcs_col_pop_card(col, ret);
  4079e1:	45 0f be 33          	movsbl (%r11),%r14d
  4079e5:	44 89 f1             	mov    %r14d,%ecx
  4079e8:	41 83 ee 01          	sub    $0x1,%r14d
  4079ec:	4d 63 f6             	movslq %r14d,%r14
  4079ef:	83 e9 01             	sub    $0x1,%ecx
  4079f2:	47 0f b6 74 33 01    	movzbl 0x1(%r11,%r14,1),%r14d
  4079f8:	41 88 0b             	mov    %cl,(%r11)
  4079fb:	48 0f be c9          	movsbq %cl,%rcx
  4079ff:	41 c6 44 0b 01 00    	movb   $0x0,0x1(%r11,%rcx,1)
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  407a05:	45 88 74 3a 40       	mov    %r14b,0x40(%r10,%rdi,1)
            ++dest_fc_idx;
  407a0a:	e9 f1 fb ff ff       	jmpq   407600 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x310>
  407a0f:	90                   	nop
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  407a10:	48 8b ac 24 c0 00 00 	mov    0xc0(%rsp),%rbp
  407a17:	00 
  407a18:	e9 a3 fe ff ff       	jmpq   4078c0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x5d0>
  407a1d:	0f 1f 00             	nopl   (%rax)
                copy_two_stacks(stack_idx, ds);
  407a20:	49 8b 34 ea          	mov    (%r10,%rbp,8),%rsi
  407a24:	44 0f ab c0          	bts    %r8d,%eax
  407a28:	89 42 14             	mov    %eax,0x14(%rdx)
  407a2b:	48 89 e8             	mov    %rbp,%rax
  407a2e:	48 c1 e0 07          	shl    $0x7,%rax
  407a32:	48 03 84 24 a0 00 00 	add    0xa0(%rsp),%rax
  407a39:	00 
  407a3a:	0f be 16             	movsbl (%rsi),%edx
  407a3d:	83 c2 01             	add    $0x1,%edx
  407a40:	48 63 d2             	movslq %edx,%rdx
  407a43:	48 83 fa 08          	cmp    $0x8,%rdx
  407a47:	0f 83 ac 01 00 00    	jae    407bf9 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x909>
  407a4d:	f6 c2 04             	test   $0x4,%dl
  407a50:	0f 85 4a 02 00 00    	jne    407ca0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9b0>
  407a56:	48 85 d2             	test   %rdx,%rdx
  407a59:	74 16                	je     407a71 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x781>
  407a5b:	0f b6 0e             	movzbl (%rsi),%ecx
  407a5e:	88 08                	mov    %cl,(%rax)
  407a60:	4c 8b 94 24 c0 00 00 	mov    0xc0(%rsp),%r10
  407a67:	00 
  407a68:	f6 c2 02             	test   $0x2,%dl
  407a6b:	0f 85 71 02 00 00    	jne    407ce2 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9f2>
  407a71:	49 89 04 ea          	mov    %rax,(%r10,%rbp,8)
  407a75:	e9 20 fb ff ff       	jmpq   40759a <fc_solve_sfs_move_stack_cards_to_different_stacks+0x2aa>
  407a7a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  407a80:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  407a84:	48 89 c7             	mov    %rax,%rdi
  407a87:	48 c1 e6 04          	shl    $0x4,%rsi
  407a8b:	e8 e0 96 ff ff       	callq  401170 <realloc@plt>
        list->states =
  407a90:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  407a95:	48 89 47 08          	mov    %rax,0x8(%rdi)
  407a99:	48 8b 17             	mov    (%rdi),%rdx
  407a9c:	e9 3f fe ff ff       	jmpq   4078e0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x5f0>
  407aa1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  407aa8:	00 00 00 00 
  407aac:	0f 1f 40 00          	nopl   0x0(%rax)
  407ab0:	0b 84 24 84 00 00 00 	or     0x84(%rsp),%eax
  407ab7:	4c 8b 94 24 c0 00 00 	mov    0xc0(%rsp),%r10
  407abe:	00 
  407abf:	89 42 14             	mov    %eax,0x14(%rdx)
  407ac2:	48 63 44 24 7c       	movslq 0x7c(%rsp),%rax
  407ac7:	49 8b 34 c2          	mov    (%r10,%rax,8),%rsi
  407acb:	0f be 0e             	movsbl (%rsi),%ecx
  407ace:	83 c1 01             	add    $0x1,%ecx
  407ad1:	48 63 c9             	movslq %ecx,%rcx
  407ad4:	48 83 f9 08          	cmp    $0x8,%rcx
  407ad8:	0f 83 f9 00 00 00    	jae    407bd7 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x8e7>
  407ade:	f6 c1 04             	test   $0x4,%cl
  407ae1:	0f 85 d2 01 00 00    	jne    407cb9 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9c9>
  407ae7:	48 85 c9             	test   %rcx,%rcx
  407aea:	74 26                	je     407b12 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x822>
  407aec:	0f b6 16             	movzbl (%rsi),%edx
  407aef:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  407af6:	00 
  407af7:	88 17                	mov    %dl,(%rdi)
  407af9:	f6 c1 02             	test   $0x2,%cl
  407afc:	0f 85 0a 02 00 00    	jne    407d0c <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa1c>
  407b02:	4c 8b 94 24 c0 00 00 	mov    0xc0(%rsp),%r10
  407b09:	00 
  407b0a:	48 8b 94 24 c8 00 00 	mov    0xc8(%rsp),%rdx
  407b11:	00 
  407b12:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  407b19:	00 
  407b1a:	49 89 3c c2          	mov    %rdi,(%r10,%rax,8)
  407b1e:	8b 42 14             	mov    0x14(%rdx),%eax
  407b21:	e9 6a fa ff ff       	jmpq   407590 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x2a0>
  407b26:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  407b2d:	00 00 00 
  407b30:	48 8b 85 f0 00 00 00 	mov    0xf0(%rbp),%rax
  407b37:	48 89 85 e8 00 00 00 	mov    %rax,0xe8(%rbp)
  407b3e:	e9 75 fd ff ff       	jmpq   4078b8 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x5c8>
        if (fcs_state_col_is_empty(state, ret))
  407b43:	bf 07 00 00 00       	mov    $0x7,%edi
  407b48:	bb 07 00 00 00       	mov    $0x7,%ebx
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  407b4d:	48 8b b4 24 c8 00 00 	mov    0xc8(%rsp),%rsi
  407b54:	00 
  407b55:	44 8d 5f 01          	lea    0x1(%rdi),%r11d
  407b59:	8b 4e 14             	mov    0x14(%rsi),%ecx
  407b5c:	0f a3 f9             	bt     %edi,%ecx
  407b5f:	0f 82 46 fc ff ff    	jb     4077ab <fc_solve_sfs_move_stack_cards_to_different_stacks+0x4bb>
  407b65:	0f ab f9             	bts    %edi,%ecx
  407b68:	c1 e7 07             	shl    $0x7,%edi
  407b6b:	89 4e 14             	mov    %ecx,0x14(%rsi)
  407b6e:	49 8d 34 da          	lea    (%r10,%rbx,8),%rsi
  407b72:	48 63 cf             	movslq %edi,%rcx
  407b75:	48 03 4c 24 70       	add    0x70(%rsp),%rcx
  407b7a:	48 89 b4 24 a8 00 00 	mov    %rsi,0xa8(%rsp)
  407b81:	00 
  407b82:	48 8b 36             	mov    (%rsi),%rsi
  407b85:	49 89 cf             	mov    %rcx,%r15
  407b88:	0f be 0e             	movsbl (%rsi),%ecx
  407b8b:	83 c1 01             	add    $0x1,%ecx
  407b8e:	48 63 c9             	movslq %ecx,%rcx
  407b91:	48 83 f9 08          	cmp    $0x8,%rcx
  407b95:	0f 83 d1 00 00 00    	jae    407c6c <fc_solve_sfs_move_stack_cards_to_different_stacks+0x97c>
  407b9b:	f6 c1 04             	test   $0x4,%cl
  407b9e:	0f 85 55 01 00 00    	jne    407cf9 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa09>
  407ba4:	48 85 c9             	test   %rcx,%rcx
  407ba7:	74 0f                	je     407bb8 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x8c8>
  407ba9:	0f b6 3e             	movzbl (%rsi),%edi
  407bac:	41 88 3f             	mov    %dil,(%r15)
  407baf:	f6 c1 02             	test   $0x2,%cl
  407bb2:	0f 85 7b 01 00 00    	jne    407d33 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa43>
  407bb8:	48 8b bc 24 a8 00 00 	mov    0xa8(%rsp),%rdi
  407bbf:	00 
  407bc0:	4c 89 3f             	mov    %r15,(%rdi)
  407bc3:	e9 e3 fb ff ff       	jmpq   4077ab <fc_solve_sfs_move_stack_cards_to_different_stacks+0x4bb>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  407bc8:	be 03 00 00 00       	mov    $0x3,%esi
  407bcd:	bf 03 00 00 00       	mov    $0x3,%edi
  407bd2:	e9 fb fd ff ff       	jmpq   4079d2 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x6e2>
                copy_two_stacks(stack_idx, ds);
  407bd7:	48 8b 54 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdx
  407bdc:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  407be3:	00 
  407be4:	48 89 54 0f f8       	mov    %rdx,-0x8(%rdi,%rcx,1)
  407be9:	48 83 e9 01          	sub    $0x1,%rcx
  407bed:	48 c1 e9 03          	shr    $0x3,%rcx
  407bf1:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  407bf4:	e9 09 ff ff ff       	jmpq   407b02 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x812>
  407bf9:	48 8b 4c 16 f8       	mov    -0x8(%rsi,%rdx,1),%rcx
  407bfe:	48 89 c7             	mov    %rax,%rdi
  407c01:	48 89 4c 10 f8       	mov    %rcx,-0x8(%rax,%rdx,1)
  407c06:	48 8d 4a ff          	lea    -0x1(%rdx),%rcx
  407c0a:	48 c1 e9 03          	shr    $0x3,%rcx
  407c0e:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  407c11:	4c 8b 94 24 c0 00 00 	mov    0xc0(%rsp),%r10
  407c18:	00 
  407c19:	e9 53 fe ff ff       	jmpq   407a71 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x781>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407c1e:	45 31 db             	xor    %r11d,%r11d
    return -1;
  407c21:	bf ff ff ff ff       	mov    $0xffffffff,%edi
  407c26:	48 c7 c3 ff ff ff ff 	mov    $0xffffffffffffffff,%rbx
  407c2d:	e9 65 fb ff ff       	jmpq   407797 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x4a7>
  407c32:	4c 89 f3             	mov    %r14,%rbx
  407c35:	e9 ce fb ff ff       	jmpq   407808 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x518>
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  407c3a:	49 89 c7             	mov    %rax,%r15
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  407c3d:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  407c42:	48 39 74 24 40       	cmp    %rsi,0x40(%rsp)
  407c47:	0f 8f 03 f8 ff ff    	jg     407450 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x160>
  407c4d:	e9 44 fd ff ff       	jmpq   407996 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x6a6>
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  407c52:	4c 8b 7c 24 20       	mov    0x20(%rsp),%r15
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  407c57:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  407c5c:	48 39 74 24 40       	cmp    %rsi,0x40(%rsp)
  407c61:	0f 8f e9 f7 ff ff    	jg     407450 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x160>
  407c67:	e9 2a fd ff ff       	jmpq   407996 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x6a6>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  407c6c:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  407c71:	49 89 7c 0f f8       	mov    %rdi,-0x8(%r15,%rcx,1)
  407c76:	48 83 e9 01          	sub    $0x1,%rcx
  407c7a:	4c 89 ff             	mov    %r15,%rdi
  407c7d:	48 c1 e9 03          	shr    $0x3,%rcx
  407c81:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  407c84:	e9 2f ff ff ff       	jmpq   407bb8 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x8c8>
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  407c89:	45 31 f6             	xor    %r14d,%r14d
  407c8c:	e9 85 f7 ff ff       	jmpq   407416 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x126>
        if (fcs_state_col_is_empty(state, ret))
  407c91:	49 63 db             	movslq %r11d,%rbx
  407c94:	41 83 c3 01          	add    $0x1,%r11d
  407c98:	48 89 df             	mov    %rbx,%rdi
  407c9b:	e9 f7 fa ff ff       	jmpq   407797 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x4a7>
                copy_two_stacks(stack_idx, ds);
  407ca0:	8b 0e                	mov    (%rsi),%ecx
  407ca2:	89 08                	mov    %ecx,(%rax)
  407ca4:	8b 4c 16 fc          	mov    -0x4(%rsi,%rdx,1),%ecx
  407ca8:	89 4c 10 fc          	mov    %ecx,-0x4(%rax,%rdx,1)
  407cac:	4c 8b 94 24 c0 00 00 	mov    0xc0(%rsp),%r10
  407cb3:	00 
  407cb4:	e9 b8 fd ff ff       	jmpq   407a71 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x781>
  407cb9:	8b 16                	mov    (%rsi),%edx
  407cbb:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  407cc2:	00 
  407cc3:	89 17                	mov    %edx,(%rdi)
  407cc5:	8b 54 0e fc          	mov    -0x4(%rsi,%rcx,1),%edx
  407cc9:	89 54 0f fc          	mov    %edx,-0x4(%rdi,%rcx,1)
  407ccd:	4c 8b 94 24 c0 00 00 	mov    0xc0(%rsp),%r10
  407cd4:	00 
  407cd5:	48 8b 94 24 c8 00 00 	mov    0xc8(%rsp),%rdx
  407cdc:	00 
  407cdd:	e9 30 fe ff ff       	jmpq   407b12 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x822>
  407ce2:	0f b7 4c 16 fe       	movzwl -0x2(%rsi,%rdx,1),%ecx
  407ce7:	66 89 4c 10 fe       	mov    %cx,-0x2(%rax,%rdx,1)
  407cec:	4c 8b 94 24 c0 00 00 	mov    0xc0(%rsp),%r10
  407cf3:	00 
  407cf4:	e9 78 fd ff ff       	jmpq   407a71 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x781>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  407cf9:	8b 3e                	mov    (%rsi),%edi
  407cfb:	41 89 3f             	mov    %edi,(%r15)
  407cfe:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  407d02:	41 89 74 0f fc       	mov    %esi,-0x4(%r15,%rcx,1)
  407d07:	e9 ac fe ff ff       	jmpq   407bb8 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x8c8>
                copy_two_stacks(stack_idx, ds);
  407d0c:	0f b7 54 0e fe       	movzwl -0x2(%rsi,%rcx,1),%edx
  407d11:	48 8b b4 24 98 00 00 	mov    0x98(%rsp),%rsi
  407d18:	00 
  407d19:	66 89 54 0e fe       	mov    %dx,-0x2(%rsi,%rcx,1)
  407d1e:	4c 8b 94 24 c0 00 00 	mov    0xc0(%rsp),%r10
  407d25:	00 
  407d26:	48 8b 94 24 c8 00 00 	mov    0xc8(%rsp),%rdx
  407d2d:	00 
  407d2e:	e9 df fd ff ff       	jmpq   407b12 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x822>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  407d33:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  407d38:	66 41 89 74 0f fe    	mov    %si,-0x2(%r15,%rcx,1)
  407d3e:	e9 75 fe ff ff       	jmpq   407bb8 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x8c8>
  407d43:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  407d4a:	00 00 00 00 
  407d4e:	66 90                	xchg   %ax,%ax

0000000000407d50 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack>:
{
  407d50:	41 57                	push   %r15
  407d52:	41 56                	push   %r14
    return -1;
  407d54:	49 89 fe             	mov    %rdi,%r14
{
  407d57:	41 55                	push   %r13
  407d59:	41 54                	push   %r12
  407d5b:	55                   	push   %rbp
  407d5c:	53                   	push   %rbx
  407d5d:	48 81 ec a8 00 00 00 	sub    $0xa8,%rsp
    return (soft_thread->num_vacant_freecells +
  407d64:	0f b6 87 e4 01 00 00 	movzbl 0x1e4(%rdi),%eax
  407d6b:	02 87 e3 01 00 00    	add    0x1e3(%rdi),%al
{
  407d71:	48 89 54 24 48       	mov    %rdx,0x48(%rsp)
    MOVE_FUNCS__define_common();
  407d76:	48 8b 17             	mov    (%rdi),%rdx
{
  407d79:	48 89 74 24 38       	mov    %rsi,0x38(%rsp)
  407d7e:	48 89 4c 24 10       	mov    %rcx,0x10(%rsp)
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  407d83:	c7 44 24 28 00 00 00 	movl   $0x0,0x28(%rsp)
  407d8a:	00 
    const fcs_game_limit num_vacant_slots_plus_1 =
  407d8b:	83 c0 01             	add    $0x1,%eax
  407d8e:	0f b6 c0             	movzbl %al,%eax
    MOVE_FUNCS__define_common();
  407d91:	48 89 54 24 40       	mov    %rdx,0x40(%rsp)
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  407d96:	89 44 24 6c          	mov    %eax,0x6c(%rsp)
  407d9a:	48 8d 82 00 01 00 00 	lea    0x100(%rdx),%rax
  407da1:	48 89 44 24 50       	mov    %rax,0x50(%rsp)
  407da6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  407dad:	00 00 00 
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  407db0:	4c 63 7c 24 28       	movslq 0x28(%rsp),%r15
static inline int max0(const int e) { return max(e, 0); }
  407db5:	ba 00 00 00 00       	mov    $0x0,%edx
  407dba:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  407dbf:	4a 8b 04 f8          	mov    (%rax,%r15,8),%rax
  407dc3:	48 89 44 24 30       	mov    %rax,0x30(%rsp)
        const int cards_num = fcs_col_len(col);
  407dc8:	0f be 00             	movsbl (%rax),%eax
  407dcb:	89 c3                	mov    %eax,%ebx
  407dcd:	2b 5c 24 6c          	sub    0x6c(%rsp),%ebx
  407dd1:	0f 49 d3             	cmovns %ebx,%edx
  407dd4:	89 54 24 68          	mov    %edx,0x68(%rsp)
        for (int c = start_dc + 2; c < cards_num; c++)
  407dd8:	83 c2 02             	add    $0x2,%edx
  407ddb:	39 d0                	cmp    %edx,%eax
  407ddd:	0f 8e 50 09 00 00    	jle    408733 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9e3>
  407de3:	0f b6 4c 24 28       	movzbl 0x28(%rsp),%ecx
  407de8:	83 e8 02             	sub    $0x2,%eax
  407deb:	be 01 00 00 00       	mov    $0x1,%esi
  407df0:	48 63 da             	movslq %edx,%rbx
  407df3:	2b 44 24 68          	sub    0x68(%rsp),%eax
  407df7:	48 89 5c 24 20       	mov    %rbx,0x20(%rsp)
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  407dfc:	4d 89 f5             	mov    %r14,%r13
  407dff:	d3 e6                	shl    %cl,%esi
  407e01:	89 74 24 2c          	mov    %esi,0x2c(%rsp)
  407e05:	89 44 24 1c          	mov    %eax,0x1c(%rsp)
  407e09:	eb 16                	jmp    407e21 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xd1>
  407e0b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  407e10:	48 83 44 24 20 01    	addq   $0x1,0x20(%rsp)
        for (int c = start_dc + 2; c < cards_num; c++)
  407e16:	83 6c 24 1c 01       	subl   $0x1,0x1c(%rsp)
  407e1b:	0f 84 0f 09 00 00    	je     408730 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9e0>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  407e21:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  407e26:	48 8b 5c 24 20       	mov    0x20(%rsp),%rbx
  407e2b:	48 0f be 54 18 01    	movsbq 0x1(%rax,%rbx,1),%rdx
  407e31:	48 0f be 04 18       	movsbq (%rax,%rbx,1),%rax
  407e36:	48 89 54 24 08       	mov    %rdx,0x8(%rsp)
  407e3b:	48 c1 e0 06          	shl    $0x6,%rax
            if (fcs_is_parent_card(card, fcs_col_get_card(col, below_c)))
  407e3f:	80 bc 02 c0 05 41 00 	cmpb   $0x0,0x4105c0(%rdx,%rax,1)
  407e46:	00 
  407e47:	75 c7                	jne    407e10 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc0>
            for (int dc = start_dc; dc < below_c; dc++)
  407e49:	89 d8                	mov    %ebx,%eax
  407e4b:	48 89 df             	mov    %rbx,%rdi
  407e4e:	8b 5c 24 68          	mov    0x68(%rsp),%ebx
  407e52:	83 e8 01             	sub    $0x1,%eax
  407e55:	39 c3                	cmp    %eax,%ebx
  407e57:	7d b7                	jge    407e10 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc0>
  407e59:	89 d8                	mov    %ebx,%eax
  407e5b:	f7 d0                	not    %eax
  407e5d:	44 8d 34 38          	lea    (%rax,%rdi,1),%r14d
  407e61:	48 63 c3             	movslq %ebx,%rax
  407e64:	48 8b 5c 24 30       	mov    0x30(%rsp),%rbx
  407e69:	48 8d 5c 03 02       	lea    0x2(%rbx,%rax,1),%rbx
  407e6e:	e9 f1 00 00 00       	jmpq   407f64 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x214>
  407e73:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  407e7a:	00 00 00 00 
  407e7e:	66 90                	xchg   %ax,%ax
                    var_AUTO(new_source_col,
  407e80:	4a 8b 0c c1          	mov    (%rcx,%r8,8),%rcx
                    fcs_col_pop_card(new_source_col, moved_card);
  407e84:	0f be 11             	movsbl (%rcx),%edx
  407e87:	89 d0                	mov    %edx,%eax
  407e89:	83 ea 01             	sub    $0x1,%edx
  407e8c:	83 e8 01             	sub    $0x1,%eax
  407e8f:	48 63 d2             	movslq %edx,%rdx
  407e92:	0f b6 74 11 01       	movzbl 0x1(%rcx,%rdx,1),%esi
  407e97:	88 01                	mov    %al,(%rcx)
  407e99:	48 0f be c0          	movsbq %al,%rax
  407e9d:	c6 44 01 01 00       	movb   $0x0,0x1(%rcx,%rax,1)
                    fcs_push_1card_seq(moves, s_idx, ds);
  407ea2:	48 8b 8c 24 80 00 00 	mov    0x80(%rsp),%rcx
  407ea9:	00 
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  407eaa:	4a 8b 14 f9          	mov    (%rcx,%r15,8),%rdx
    fcs_col_push_card(col, card);
  407eae:	48 0f be 02          	movsbq (%rdx),%rax
  407eb2:	8d 48 01             	lea    0x1(%rax),%ecx
  407eb5:	88 0a                	mov    %cl,(%rdx)
  407eb7:	40 88 74 02 01       	mov    %sil,0x1(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  407ebc:	49 8b 6d 00          	mov    0x0(%r13),%rbp
    if (!fc_solve_check_and_add_state(
  407ec0:	48 8d 94 24 90 00 00 	lea    0x90(%rsp),%rdx
  407ec7:	00 
  407ec8:	48 8d b4 24 80 00 00 	lea    0x80(%rsp),%rsi
  407ecf:	00 
  407ed0:	48 89 ef             	mov    %rbp,%rdi
  407ed3:	e8 98 9c ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  407ed8:	84 c0                	test   %al,%al
  407eda:	0f 85 80 01 00 00    	jne    408060 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x310>
        if (HT_FIELD(hard_thread, allocated_from_list))
  407ee0:	80 bd 18 05 00 00 00 	cmpb   $0x0,0x518(%rbp)
  407ee7:	0f 84 d3 03 00 00    	je     4082c0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x570>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  407eed:	48 8b 95 b0 00 00 00 	mov    0xb0(%rbp),%rdx
  407ef4:	48 8b 84 24 88 00 00 	mov    0x88(%rsp),%rax
  407efb:	00 
  407efc:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  407eff:	48 8b 84 24 80 00 00 	mov    0x80(%rsp),%rax
  407f06:	00 
  407f07:	48 89 85 b0 00 00 00 	mov    %rax,0xb0(%rbp)
        return FCS_STATE_kv_to_collectible(&existing_state);
  407f0e:	48 8b ac 24 90 00 00 	mov    0x90(%rsp),%rbp
  407f15:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  407f16:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
  407f1b:	31 f6                	xor    %esi,%esi
  407f1d:	48 8b 38             	mov    (%rax),%rdi
  407f20:	48 8b 40 08          	mov    0x8(%rax),%rax
  407f24:	48 85 c0             	test   %rax,%rax
  407f27:	40 0f 95 c6          	setne  %sil
  407f2b:	48 01 fe             	add    %rdi,%rsi
  407f2e:	40 f6 c6 0f          	test   $0xf,%sil
  407f32:	0f 84 38 01 00 00    	je     408070 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x320>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  407f38:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  407f3d:	48 8d 57 01          	lea    0x1(%rdi),%rdx
  407f41:	48 c1 e7 04          	shl    $0x4,%rdi
  407f45:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  407f49:	48 01 f8             	add    %rdi,%rax
  407f4c:	48 89 16             	mov    %rdx,(%rsi)
  407f4f:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  407f53:	48 89 28             	mov    %rbp,(%rax)
  407f56:	48 83 c3 01          	add    $0x1,%rbx
            for (int dc = start_dc; dc < below_c; dc++)
  407f5a:	41 83 ee 01          	sub    $0x1,%r14d
  407f5e:	0f 84 ac fe ff ff    	je     407e10 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc0>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  407f64:	48 0f be 43 ff       	movsbq -0x1(%rbx),%rax
  407f69:	48 8b 54 24 08       	mov    0x8(%rsp),%rdx
  407f6e:	48 c1 e0 06          	shl    $0x6,%rax
  407f72:	0f b6 ac 10 c0 05 41 	movzbl 0x4105c0(%rax,%rdx,1),%ebp
  407f79:	00 
  407f7a:	48 05 c0 05 41 00    	add    $0x4105c0,%rax
                if ((!fcs_is_parent_card(card, dest_card)) ||
  407f80:	40 84 ed             	test   %bpl,%bpl
  407f83:	74 d1                	je     407f56 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x206>
  407f85:	48 0f be 13          	movsbq (%rbx),%rdx
  407f89:	80 3c 10 00          	cmpb   $0x0,(%rax,%rdx,1)
  407f8d:	75 c7                	jne    407f56 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x206>
                sfs_check_state_begin();
  407f8f:	48 8b 54 24 38       	mov    0x38(%rsp),%rdx
  407f94:	48 8d b4 24 80 00 00 	lea    0x80(%rsp),%rsi
  407f9b:	00 
  407f9c:	48 8b 4c 24 48       	mov    0x48(%rsp),%rcx
  407fa1:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  407fa6:	e8 75 9a ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
                my_copy_stack(ds);
  407fab:	48 8b 94 24 88 00 00 	mov    0x88(%rsp),%rdx
  407fb2:	00 
  407fb3:	8b 42 14             	mov    0x14(%rdx),%eax
  407fb6:	85 44 24 2c          	test   %eax,0x2c(%rsp)
  407fba:	0f 84 e0 00 00 00    	je     4080a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x350>
  407fc0:	48 8b 94 24 80 00 00 	mov    0x80(%rsp),%rdx
  407fc7:	00 
                const int cols_indexes[3] = {ds, -1, -1};
  407fc8:	8b 44 24 28          	mov    0x28(%rsp),%eax
  407fcc:	49 c7 c0 ff ff ff ff 	mov    $0xffffffffffffffff,%r8
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  407fd3:	48 bf 00 00 00 00 ff 	movabs $0xffffffff00000000,%rdi
  407fda:	ff ff ff 
                const int cols_indexes[3] = {ds, -1, -1};
  407fdd:	4c 89 44 24 78       	mov    %r8,0x78(%rsp)
                    empty_two_cols_from_new_state(soft_thread,
  407fe2:	4d 8b 55 00          	mov    0x0(%r13),%r10
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  407fe6:	48 89 bc 24 94 00 00 	mov    %rdi,0x94(%rsp)
  407fed:	00 
                const int cols_indexes[3] = {ds, -1, -1};
  407fee:	89 44 24 74          	mov    %eax,0x74(%rsp)
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  407ff2:	8b 44 24 1c          	mov    0x1c(%rsp),%eax
  407ff6:	89 84 24 90 00 00 00 	mov    %eax,0x90(%rsp)
            while ((*col_num_cards) == 0)
  407ffd:	85 c0                	test   %eax,%eax
  407fff:	0f 85 fb 00 00 00    	jne    408100 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x3b0>
  408005:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40800c:	00 00 00 00 
  408010:	48 8b 84 24 80 00 00 	mov    0x80(%rsp),%rax
  408017:	00 
    while ((*col_num_cards) == 0)
  408018:	31 ed                	xor    %ebp,%ebp
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  40801a:	48 ba 00 00 00 00 ff 	movabs $0xffffffff00000000,%rdx
  408021:	ff ff ff 
                empty_two_cols_from_new_state(soft_thread,
  408024:	45 89 f1             	mov    %r14d,%r9d
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  408027:	44 89 b4 24 90 00 00 	mov    %r14d,0x90(%rsp)
  40802e:	00 
  40802f:	48 89 94 24 94 00 00 	mov    %rdx,0x94(%rsp)
  408036:	00 
            while ((*col_num_cards) == 0)
  408037:	45 85 f6             	test   %r14d,%r14d
  40803a:	0f 85 a0 01 00 00    	jne    4081e0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x490>
  408040:	48 89 c1             	mov    %rax,%rcx
                if (last_dest.is_col)
  408043:	40 84 ed             	test   %bpl,%bpl
  408046:	0f 85 34 fe ff ff    	jne    407e80 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x130>
                    moved_card = fcs_freecell_card(new_state_key, s_idx);
  40804c:	42 0f b6 74 01 40    	movzbl 0x40(%rcx,%r8,1),%esi
                    fcs_empty_freecell(new_state_key, s_idx);
  408052:	42 c6 44 01 40 00    	movb   $0x0,0x40(%rcx,%r8,1)
  408058:	e9 4d fe ff ff       	jmpq   407eaa <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x15a>
  40805d:	0f 1f 00             	nopl   (%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  408060:	48 8b ac 24 80 00 00 	mov    0x80(%rsp),%rbp
  408067:	00 
  408068:	e9 a9 fe ff ff       	jmpq   407f16 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x1c6>
  40806d:	0f 1f 00             	nopl   (%rax)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  408070:	48 83 c6 10          	add    $0x10,%rsi
  408074:	48 89 c7             	mov    %rax,%rdi
  408077:	48 c1 e6 04          	shl    $0x4,%rsi
  40807b:	e8 f0 90 ff ff       	callq  401170 <realloc@plt>
        list->states =
  408080:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  408085:	48 89 47 08          	mov    %rax,0x8(%rdi)
  408089:	48 8b 3f             	mov    (%rdi),%rdi
  40808c:	e9 a7 fe ff ff       	jmpq   407f38 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x1e8>
  408091:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  408098:	00 00 00 00 
  40809c:	0f 1f 40 00          	nopl   0x0(%rax)
                my_copy_stack(ds);
  4080a0:	0b 44 24 2c          	or     0x2c(%rsp),%eax
  4080a4:	89 42 14             	mov    %eax,0x14(%rdx)
  4080a7:	48 8b 94 24 80 00 00 	mov    0x80(%rsp),%rdx
  4080ae:	00 
  4080af:	4a 8b 34 fa          	mov    (%rdx,%r15,8),%rsi
  4080b3:	0f be 06             	movsbl (%rsi),%eax
  4080b6:	83 c0 01             	add    $0x1,%eax
  4080b9:	48 98                	cltq   
  4080bb:	48 83 f8 08          	cmp    $0x8,%rax
  4080bf:	0f 83 3b 02 00 00    	jae    408300 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x5b0>
  4080c5:	a8 04                	test   $0x4,%al
  4080c7:	0f 85 ee 06 00 00    	jne    4087bb <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa6b>
  4080cd:	48 85 c0             	test   %rax,%rax
  4080d0:	74 1a                	je     4080ec <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x39c>
  4080d2:	0f b6 16             	movzbl (%rsi),%edx
  4080d5:	48 8b 7c 24 50       	mov    0x50(%rsp),%rdi
  4080da:	88 17                	mov    %dl,(%rdi)
  4080dc:	48 8b 94 24 80 00 00 	mov    0x80(%rsp),%rdx
  4080e3:	00 
  4080e4:	a8 02                	test   $0x2,%al
  4080e6:	0f 85 11 07 00 00    	jne    4087fd <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xaad>
  4080ec:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  4080f1:	4a 89 04 fa          	mov    %rax,(%rdx,%r15,8)
  4080f5:	e9 ce fe ff ff       	jmpq   407fc8 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x278>
  4080fa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            while ((*col_num_cards) == 0)
  408100:	89 c7                	mov    %eax,%edi
  408102:	41 89 c1             	mov    %eax,%r9d
        int dest_fc_idx = 0;
  408105:	31 c0                	xor    %eax,%eax
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408107:	48 63 c8             	movslq %eax,%rcx
            while ((*col_num_cards) == 0)
  40810a:	45 31 c0             	xor    %r8d,%r8d
    empty_two_cols_ret ret = {.src_idx = -1, .is_col = FALSE};
  40810d:	be ff ff ff ff       	mov    $0xffffffff,%esi
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408112:	80 7c 0a 40 00       	cmpb   $0x0,0x40(%rdx,%rcx,1)
  408117:	0f 84 bf 00 00 00    	je     4081dc <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x48c>
  40811d:	0f 1f 00             	nopl   (%rax)
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408120:	8d 48 01             	lea    0x1(%rax),%ecx
  408123:	83 f9 04             	cmp    $0x4,%ecx
  408126:	74 2c                	je     408154 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x404>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408128:	4c 63 d9             	movslq %ecx,%r11
  40812b:	42 80 7c 1a 40 00    	cmpb   $0x0,0x40(%rdx,%r11,1)
  408131:	74 4d                	je     408180 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x430>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408133:	8d 48 02             	lea    0x2(%rax),%ecx
  408136:	83 f9 04             	cmp    $0x4,%ecx
  408139:	74 19                	je     408154 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x404>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  40813b:	4c 63 d9             	movslq %ecx,%r11
  40813e:	42 80 7c 1a 40 00    	cmpb   $0x0,0x40(%rdx,%r11,1)
  408144:	74 3a                	je     408180 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x430>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408146:	85 c0                	test   %eax,%eax
  408148:	75 0a                	jne    408154 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x404>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  40814a:	80 7a 43 00          	cmpb   $0x0,0x43(%rdx)
  40814e:	0f 84 9c 01 00 00    	je     4082f0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x5a0>
  408154:	45 84 c0             	test   %r8b,%r8b
  408157:	74 07                	je     408160 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x410>
  408159:	89 bc 24 90 00 00 00 	mov    %edi,0x90(%rsp)
    while ((*col_num_cards) == 0)
  408160:	45 85 c9             	test   %r9d,%r9d
  408163:	0f 85 be 01 00 00    	jne    408327 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x5d7>
  408169:	48 8b 84 24 80 00 00 	mov    0x80(%rsp),%rax
  408170:	00 
  408171:	31 ed                	xor    %ebp,%ebp
  408173:	4c 63 c6             	movslq %esi,%r8
  408176:	4d 8b 55 00          	mov    0x0(%r13),%r10
  40817a:	e9 9b fe ff ff       	jmpq   40801a <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x2ca>
  40817f:	90                   	nop
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408180:	89 ce                	mov    %ecx,%esi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408182:	4a 8b 3c fa          	mov    (%rdx,%r15,8),%rdi
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  408186:	4c 63 c6             	movslq %esi,%r8
    fcs_col_pop_card(col, ret);
  408189:	0f be 0f             	movsbl (%rdi),%ecx
  40818c:	89 c8                	mov    %ecx,%eax
  40818e:	83 e9 01             	sub    $0x1,%ecx
  408191:	48 63 c9             	movslq %ecx,%rcx
  408194:	83 e8 01             	sub    $0x1,%eax
  408197:	0f b6 4c 0f 01       	movzbl 0x1(%rdi,%rcx,1),%ecx
  40819c:	88 07                	mov    %al,(%rdi)
  40819e:	48 0f be c0          	movsbq %al,%rax
  4081a2:	c6 44 07 01 00       	movb   $0x0,0x1(%rdi,%rax,1)
            ++dest_fc_idx;
  4081a7:	8d 46 01             	lea    0x1(%rsi),%eax
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  4081aa:	42 88 4c 02 40       	mov    %cl,0x40(%rdx,%r8,1)
            while ((*col_num_cards) == 0)
  4081af:	41 83 e9 01          	sub    $0x1,%r9d
  4081b3:	75 0b                	jne    4081c0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x470>
  4081b5:	4d 8b 55 00          	mov    0x0(%r13),%r10
  4081b9:	e9 52 fe ff ff       	jmpq   408010 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x2c0>
  4081be:	66 90                	xchg   %ax,%ax
  4081c0:	41 b8 01 00 00 00    	mov    $0x1,%r8d
  4081c6:	44 89 cf             	mov    %r9d,%edi
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4081c9:	83 f8 04             	cmp    $0x4,%eax
  4081cc:	74 8b                	je     408159 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x409>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4081ce:	48 63 c8             	movslq %eax,%rcx
  4081d1:	80 7c 0a 40 00       	cmpb   $0x0,0x40(%rdx,%rcx,1)
  4081d6:	0f 85 44 ff ff ff    	jne    408120 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x3d0>
  4081dc:	89 c6                	mov    %eax,%esi
  4081de:	eb a2                	jmp    408182 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x432>
            const_AUTO(top_card, fcs_state_pop_col_card(new_key, *col_idx));
  4081e0:	8b 7c 24 74          	mov    0x74(%rsp),%edi
  4081e4:	44 89 f2             	mov    %r14d,%edx
  4081e7:	45 31 db             	xor    %r11d,%r11d
  4081ea:	4c 63 e7             	movslq %edi,%r12
        int dest_fc_idx = 0;
  4081ed:	31 ff                	xor    %edi,%edi
            const_AUTO(top_card, fcs_state_pop_col_card(new_key, *col_idx));
  4081ef:	44 89 64 24 58       	mov    %r12d,0x58(%rsp)
  4081f4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4081fb:	00 00 00 00 
  4081ff:	90                   	nop
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408200:	48 63 f7             	movslq %edi,%rsi
  408203:	80 7c 30 40 00       	cmpb   $0x0,0x40(%rax,%rsi,1)
  408208:	74 68                	je     408272 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x522>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  40820a:	8d 4f 01             	lea    0x1(%rdi),%ecx
  40820d:	83 f9 04             	cmp    $0x4,%ecx
  408210:	74 2a                	je     40823c <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x4ec>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408212:	48 63 f1             	movslq %ecx,%rsi
  408215:	80 7c 30 40 00       	cmpb   $0x0,0x40(%rax,%rsi,1)
  40821a:	74 54                	je     408270 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x520>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  40821c:	8d 4f 02             	lea    0x2(%rdi),%ecx
  40821f:	83 f9 04             	cmp    $0x4,%ecx
  408222:	74 18                	je     40823c <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x4ec>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408224:	48 63 f1             	movslq %ecx,%rsi
  408227:	80 7c 30 40 00       	cmpb   $0x0,0x40(%rax,%rsi,1)
  40822c:	74 42                	je     408270 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x520>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  40822e:	85 ff                	test   %edi,%edi
  408230:	75 0a                	jne    40823c <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x4ec>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408232:	80 78 43 00          	cmpb   $0x0,0x43(%rax)
  408236:	0f 84 a4 00 00 00    	je     4082e0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x590>
  40823c:	45 84 db             	test   %r11b,%r11b
  40823f:	74 08                	je     408249 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x4f9>
  408241:	44 89 8c 24 90 00 00 	mov    %r9d,0x90(%rsp)
  408248:	00 
    while ((*col_num_cards) == 0)
  408249:	85 d2                	test   %edx,%edx
  40824b:	0f 85 c7 02 00 00    	jne    408518 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7c8>
  408251:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  408258:	00 00 00 00 
  40825c:	0f 1f 40 00          	nopl   0x0(%rax)
  408260:	48 8b 84 24 80 00 00 	mov    0x80(%rsp),%rax
  408267:	00 
  408268:	e9 d3 fd ff ff       	jmpq   408040 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x2f0>
  40826d:	0f 1f 00             	nopl   (%rax)
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408270:	89 cf                	mov    %ecx,%edi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408272:	4e 8b 0c e0          	mov    (%rax,%r12,8),%r9
            ++dest_fc_idx;
  408276:	83 c7 01             	add    $0x1,%edi
    fcs_col_pop_card(col, ret);
  408279:	45 0f be 19          	movsbl (%r9),%r11d
  40827d:	44 89 d9             	mov    %r11d,%ecx
  408280:	41 83 eb 01          	sub    $0x1,%r11d
  408284:	4d 63 db             	movslq %r11d,%r11
  408287:	83 e9 01             	sub    $0x1,%ecx
  40828a:	47 0f b6 5c 19 01    	movzbl 0x1(%r9,%r11,1),%r11d
  408290:	41 88 09             	mov    %cl,(%r9)
  408293:	48 0f be c9          	movsbq %cl,%rcx
  408297:	41 c6 44 09 01 00    	movb   $0x0,0x1(%r9,%rcx,1)
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  40829d:	44 88 5c 30 40       	mov    %r11b,0x40(%rax,%rsi,1)
            while ((*col_num_cards) == 0)
  4082a2:	83 ea 01             	sub    $0x1,%edx
  4082a5:	74 b9                	je     408260 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x510>
  4082a7:	41 89 d1             	mov    %edx,%r9d
  4082aa:	41 bb 01 00 00 00    	mov    $0x1,%r11d
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4082b0:	83 ff 04             	cmp    $0x4,%edi
  4082b3:	0f 85 47 ff ff ff    	jne    408200 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x4b0>
  4082b9:	eb 86                	jmp    408241 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x4f1>
  4082bb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  4082c0:	48 8b 85 f0 00 00 00 	mov    0xf0(%rbp),%rax
  4082c7:	48 89 85 e8 00 00 00 	mov    %rax,0xe8(%rbp)
  4082ce:	e9 3b fc ff ff       	jmpq   407f0e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x1be>
  4082d3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4082da:	00 00 00 00 
  4082de:	66 90                	xchg   %ax,%ax
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4082e0:	bf 03 00 00 00       	mov    $0x3,%edi
  4082e5:	be 03 00 00 00       	mov    $0x3,%esi
  4082ea:	eb 86                	jmp    408272 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x522>
  4082ec:	0f 1f 40 00          	nopl   0x0(%rax)
  4082f0:	be 03 00 00 00       	mov    $0x3,%esi
  4082f5:	e9 88 fe ff ff       	jmpq   408182 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x432>
  4082fa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                my_copy_stack(ds);
  408300:	48 8b 54 06 f8       	mov    -0x8(%rsi,%rax,1),%rdx
  408305:	48 8d 48 ff          	lea    -0x1(%rax),%rcx
  408309:	48 8b 7c 24 50       	mov    0x50(%rsp),%rdi
  40830e:	48 c1 e9 03          	shr    $0x3,%rcx
  408312:	48 89 54 07 f8       	mov    %rdx,-0x8(%rdi,%rax,1)
  408317:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40831a:	48 8b 94 24 80 00 00 	mov    0x80(%rsp),%rdx
  408321:	00 
  408322:	e9 c5 fd ff ff       	jmpq   4080ec <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x39c>
  408327:	48 8b 8c 24 80 00 00 	mov    0x80(%rsp),%rcx
  40832e:	00 
    char *const indirect_stacks_buffer =
  40832f:	49 8d 82 00 01 00 00 	lea    0x100(%r10),%rax
    int put_cards_in_col_idx = 0;
  408336:	45 31 db             	xor    %r11d,%r11d
  408339:	49 c7 c4 ff ff ff ff 	mov    $0xffffffffffffffff,%r12
    char *const indirect_stacks_buffer =
  408340:	48 89 44 24 58       	mov    %rax,0x58(%rsp)
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408345:	41 83 fb 08          	cmp    $0x8,%r11d
  408349:	0f 84 c1 01 00 00    	je     408510 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7c0>
        if (fcs_state_col_is_empty(state, ret))
  40834f:	49 63 c3             	movslq %r11d,%rax
  408352:	48 8b 04 c1          	mov    (%rcx,%rax,8),%rax
  408356:	80 38 00             	cmpb   $0x0,(%rax)
  408359:	0f 84 3e 04 00 00    	je     40879d <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa4d>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40835f:	41 8d 43 01          	lea    0x1(%r11),%eax
  408363:	83 f8 08             	cmp    $0x8,%eax
  408366:	0f 84 a4 01 00 00    	je     408510 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7c0>
        if (fcs_state_col_is_empty(state, ret))
  40836c:	4c 63 c0             	movslq %eax,%r8
  40836f:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  408373:	80 3e 00             	cmpb   $0x0,(%rsi)
  408376:	0f 84 24 01 00 00    	je     4084a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x750>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40837c:	41 8d 43 02          	lea    0x2(%r11),%eax
  408380:	83 f8 08             	cmp    $0x8,%eax
  408383:	0f 84 87 01 00 00    	je     408510 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7c0>
        if (fcs_state_col_is_empty(state, ret))
  408389:	4c 63 c0             	movslq %eax,%r8
  40838c:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  408390:	80 3e 00             	cmpb   $0x0,(%rsi)
  408393:	0f 84 07 01 00 00    	je     4084a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x750>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408399:	41 8d 43 03          	lea    0x3(%r11),%eax
  40839d:	83 f8 08             	cmp    $0x8,%eax
  4083a0:	0f 84 6a 01 00 00    	je     408510 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7c0>
        if (fcs_state_col_is_empty(state, ret))
  4083a6:	4c 63 c0             	movslq %eax,%r8
  4083a9:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  4083ad:	80 3e 00             	cmpb   $0x0,(%rsi)
  4083b0:	0f 84 ea 00 00 00    	je     4084a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x750>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4083b6:	41 8d 43 04          	lea    0x4(%r11),%eax
  4083ba:	83 f8 08             	cmp    $0x8,%eax
  4083bd:	0f 84 4d 01 00 00    	je     408510 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7c0>
        if (fcs_state_col_is_empty(state, ret))
  4083c3:	4c 63 c0             	movslq %eax,%r8
  4083c6:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  4083ca:	80 3e 00             	cmpb   $0x0,(%rsi)
  4083cd:	0f 84 cd 00 00 00    	je     4084a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x750>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4083d3:	41 8d 43 05          	lea    0x5(%r11),%eax
  4083d7:	83 f8 08             	cmp    $0x8,%eax
  4083da:	0f 84 30 01 00 00    	je     408510 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7c0>
        if (fcs_state_col_is_empty(state, ret))
  4083e0:	4c 63 c0             	movslq %eax,%r8
  4083e3:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  4083e7:	80 3e 00             	cmpb   $0x0,(%rsi)
  4083ea:	0f 84 b0 00 00 00    	je     4084a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x750>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4083f0:	41 8d 43 06          	lea    0x6(%r11),%eax
  4083f4:	83 f8 08             	cmp    $0x8,%eax
  4083f7:	0f 84 13 01 00 00    	je     408510 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7c0>
        if (fcs_state_col_is_empty(state, ret))
  4083fd:	4c 63 c0             	movslq %eax,%r8
  408400:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  408404:	80 3e 00             	cmpb   $0x0,(%rsi)
  408407:	0f 84 93 00 00 00    	je     4084a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x750>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40840d:	45 85 db             	test   %r11d,%r11d
  408410:	0f 85 fa 00 00 00    	jne    408510 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7c0>
        if (fcs_state_col_is_empty(state, ret))
  408416:	48 8b 41 38          	mov    0x38(%rcx),%rax
  40841a:	80 38 00             	cmpb   $0x0,(%rax)
  40841d:	74 76                	je     408495 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x745>
    return -1;
  40841f:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
  408424:	4d 89 e0             	mov    %r12,%r8
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408427:	48 8b b4 24 88 00 00 	mov    0x88(%rsp),%rsi
  40842e:	00 
  40842f:	8b 4e 14             	mov    0x14(%rsi),%ecx
  408432:	0f a3 c1             	bt     %eax,%ecx
  408435:	0f 83 7d 00 00 00    	jae    4084b8 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x768>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  40843b:	4a 8b 34 fa          	mov    (%rdx,%r15,8),%rsi
    fcs_col_pop_card(col, ret);
  40843f:	0f be 0e             	movsbl (%rsi),%ecx
  408442:	89 c8                	mov    %ecx,%eax
  408444:	83 e9 01             	sub    $0x1,%ecx
  408447:	83 e8 01             	sub    $0x1,%eax
  40844a:	48 63 c9             	movslq %ecx,%rcx
        --(*col_num_cards);
  40844d:	41 83 e9 01          	sub    $0x1,%r9d
  408451:	0f b6 4c 0e 01       	movzbl 0x1(%rsi,%rcx,1),%ecx
  408456:	88 06                	mov    %al,(%rsi)
  408458:	48 0f be c0          	movsbq %al,%rax
  40845c:	c6 44 06 01 00       	movb   $0x0,0x1(%rsi,%rax,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408461:	4a 8b 34 c2          	mov    (%rdx,%r8,8),%rsi
    fcs_col_push_card(col, card);
  408465:	48 0f be 06          	movsbq (%rsi),%rax
  408469:	8d 78 01             	lea    0x1(%rax),%edi
  40846c:	40 88 3e             	mov    %dil,(%rsi)
  40846f:	88 4c 06 01          	mov    %cl,0x1(%rsi,%rax,1)
  408473:	48 8b 84 24 80 00 00 	mov    0x80(%rsp),%rax
  40847a:	00 
  40847b:	44 89 8c 24 90 00 00 	mov    %r9d,0x90(%rsp)
  408482:	00 
  408483:	48 89 c1             	mov    %rax,%rcx
        while ((*col_num_cards) == 0)
  408486:	0f 85 b9 fe ff ff    	jne    408345 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x5f5>
  40848c:	4d 8b 55 00          	mov    0x0(%r13),%r10
  408490:	e9 85 fb ff ff       	jmpq   40801a <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x2ca>
        if (fcs_state_col_is_empty(state, ret))
  408495:	b8 07 00 00 00       	mov    $0x7,%eax
  40849a:	41 b8 07 00 00 00    	mov    $0x7,%r8d
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4084a0:	48 8b b4 24 88 00 00 	mov    0x88(%rsp),%rsi
  4084a7:	00 
  4084a8:	44 8d 58 01          	lea    0x1(%rax),%r11d
  4084ac:	8b 4e 14             	mov    0x14(%rsi),%ecx
  4084af:	0f a3 c1             	bt     %eax,%ecx
  4084b2:	0f 82 83 ff ff ff    	jb     40843b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x6eb>
  4084b8:	4e 8d 14 c2          	lea    (%rdx,%r8,8),%r10
  4084bc:	0f ab c1             	bts    %eax,%ecx
  4084bf:	c1 e0 07             	shl    $0x7,%eax
  4084c2:	89 4e 14             	mov    %ecx,0x14(%rsi)
  4084c5:	49 8b 32             	mov    (%r10),%rsi
  4084c8:	48 98                	cltq   
  4084ca:	48 03 44 24 58       	add    0x58(%rsp),%rax
  4084cf:	0f be 0e             	movsbl (%rsi),%ecx
  4084d2:	83 c1 01             	add    $0x1,%ecx
  4084d5:	48 63 c9             	movslq %ecx,%rcx
  4084d8:	48 83 f9 08          	cmp    $0x8,%rcx
  4084dc:	0f 83 9e 02 00 00    	jae    408780 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa30>
  4084e2:	f6 c1 04             	test   $0x4,%cl
  4084e5:	0f 85 01 03 00 00    	jne    4087ec <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa9c>
  4084eb:	48 85 c9             	test   %rcx,%rcx
  4084ee:	74 0f                	je     4084ff <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7af>
  4084f0:	0f b6 3e             	movzbl (%rsi),%edi
  4084f3:	40 88 38             	mov    %dil,(%rax)
  4084f6:	f6 c1 02             	test   $0x2,%cl
  4084f9:	0f 85 1a 03 00 00    	jne    408819 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xac9>
  4084ff:	49 89 02             	mov    %rax,(%r10)
  408502:	e9 34 ff ff ff       	jmpq   40843b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x6eb>
  408507:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40850e:	00 00 
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408510:	45 31 db             	xor    %r11d,%r11d
  408513:	e9 07 ff ff ff       	jmpq   40841f <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x6cf>
    char *const indirect_stacks_buffer =
  408518:	49 8d ba 00 01 00 00 	lea    0x100(%r10),%rdi
    int put_cards_in_col_idx = 0;
  40851f:	45 31 db             	xor    %r11d,%r11d
  408522:	4c 63 64 24 58       	movslq 0x58(%rsp),%r12
  408527:	48 8b 8c 24 80 00 00 	mov    0x80(%rsp),%rcx
  40852e:	00 
    char *const indirect_stacks_buffer =
  40852f:	48 89 7c 24 60       	mov    %rdi,0x60(%rsp)
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408534:	41 83 fb 08          	cmp    $0x8,%r11d
  408538:	0f 84 62 01 00 00    	je     4086a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x950>
        if (fcs_state_col_is_empty(state, ret))
  40853e:	49 63 f3             	movslq %r11d,%rsi
  408541:	48 8b 34 f1          	mov    (%rcx,%rsi,8),%rsi
  408545:	80 3e 00             	cmpb   $0x0,(%rsi)
  408548:	0f 84 5e 02 00 00    	je     4087ac <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa5c>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40854e:	45 8d 4b 01          	lea    0x1(%r11),%r9d
  408552:	41 83 f9 08          	cmp    $0x8,%r9d
  408556:	0f 84 44 01 00 00    	je     4086a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x950>
        if (fcs_state_col_is_empty(state, ret))
  40855c:	4d 63 d1             	movslq %r9d,%r10
  40855f:	4a 8b 34 d1          	mov    (%rcx,%r10,8),%rsi
  408563:	80 3e 00             	cmpb   $0x0,(%rsi)
  408566:	0f 84 54 01 00 00    	je     4086c0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x970>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40856c:	45 8d 4b 02          	lea    0x2(%r11),%r9d
  408570:	41 83 f9 08          	cmp    $0x8,%r9d
  408574:	0f 84 26 01 00 00    	je     4086a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x950>
        if (fcs_state_col_is_empty(state, ret))
  40857a:	4d 63 d1             	movslq %r9d,%r10
  40857d:	4a 8b 34 d1          	mov    (%rcx,%r10,8),%rsi
  408581:	80 3e 00             	cmpb   $0x0,(%rsi)
  408584:	0f 84 36 01 00 00    	je     4086c0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x970>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40858a:	45 8d 4b 03          	lea    0x3(%r11),%r9d
  40858e:	41 83 f9 08          	cmp    $0x8,%r9d
  408592:	0f 84 08 01 00 00    	je     4086a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x950>
        if (fcs_state_col_is_empty(state, ret))
  408598:	4d 63 d1             	movslq %r9d,%r10
  40859b:	4a 8b 34 d1          	mov    (%rcx,%r10,8),%rsi
  40859f:	80 3e 00             	cmpb   $0x0,(%rsi)
  4085a2:	0f 84 18 01 00 00    	je     4086c0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x970>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4085a8:	45 8d 4b 04          	lea    0x4(%r11),%r9d
  4085ac:	41 83 f9 08          	cmp    $0x8,%r9d
  4085b0:	0f 84 ea 00 00 00    	je     4086a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x950>
        if (fcs_state_col_is_empty(state, ret))
  4085b6:	4d 63 d1             	movslq %r9d,%r10
  4085b9:	4a 8b 34 d1          	mov    (%rcx,%r10,8),%rsi
  4085bd:	80 3e 00             	cmpb   $0x0,(%rsi)
  4085c0:	0f 84 fa 00 00 00    	je     4086c0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x970>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4085c6:	45 8d 4b 05          	lea    0x5(%r11),%r9d
  4085ca:	41 83 f9 08          	cmp    $0x8,%r9d
  4085ce:	0f 84 cc 00 00 00    	je     4086a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x950>
        if (fcs_state_col_is_empty(state, ret))
  4085d4:	4d 63 d1             	movslq %r9d,%r10
  4085d7:	4a 8b 34 d1          	mov    (%rcx,%r10,8),%rsi
  4085db:	80 3e 00             	cmpb   $0x0,(%rsi)
  4085de:	0f 84 dc 00 00 00    	je     4086c0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x970>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4085e4:	45 8d 4b 06          	lea    0x6(%r11),%r9d
  4085e8:	41 83 f9 08          	cmp    $0x8,%r9d
  4085ec:	0f 84 ae 00 00 00    	je     4086a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x950>
        if (fcs_state_col_is_empty(state, ret))
  4085f2:	4d 63 d1             	movslq %r9d,%r10
  4085f5:	4a 8b 34 d1          	mov    (%rcx,%r10,8),%rsi
  4085f9:	80 3e 00             	cmpb   $0x0,(%rsi)
  4085fc:	0f 84 be 00 00 00    	je     4086c0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x970>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408602:	45 85 db             	test   %r11d,%r11d
  408605:	0f 85 95 00 00 00    	jne    4086a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x950>
        if (fcs_state_col_is_empty(state, ret))
  40860b:	48 8b 49 38          	mov    0x38(%rcx),%rcx
  40860f:	80 39 00             	cmpb   $0x0,(%rcx)
  408612:	0f 84 90 00 00 00    	je     4086a8 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x958>
    return -1;
  408618:	41 b9 ff ff ff ff    	mov    $0xffffffff,%r9d
  40861e:	49 c7 c2 ff ff ff ff 	mov    $0xffffffffffffffff,%r10
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408625:	48 8b b4 24 88 00 00 	mov    0x88(%rsp),%rsi
  40862c:	00 
  40862d:	8b 4e 14             	mov    0x14(%rsi),%ecx
  408630:	44 0f a3 c9          	bt     %r9d,%ecx
  408634:	0f 83 96 00 00 00    	jae    4086d0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x980>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  40863a:	4a 8b 34 e0          	mov    (%rax,%r12,8),%rsi
    fcs_col_pop_card(col, ret);
  40863e:	0f be 3e             	movsbl (%rsi),%edi
  408641:	89 f9                	mov    %edi,%ecx
  408643:	83 ef 01             	sub    $0x1,%edi
  408646:	83 e9 01             	sub    $0x1,%ecx
  408649:	48 63 ff             	movslq %edi,%rdi
        --(*col_num_cards);
  40864c:	83 ea 01             	sub    $0x1,%edx
  40864f:	0f b6 7c 3e 01       	movzbl 0x1(%rsi,%rdi,1),%edi
  408654:	88 0e                	mov    %cl,(%rsi)
  408656:	48 0f be c9          	movsbq %cl,%rcx
  40865a:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  40865f:	4a 8b 34 d0          	mov    (%rax,%r10,8),%rsi
    fcs_col_push_card(col, card);
  408663:	48 0f be 0e          	movsbq (%rsi),%rcx
  408667:	44 8d 49 01          	lea    0x1(%rcx),%r9d
  40866b:	44 88 0e             	mov    %r9b,(%rsi)
  40866e:	40 88 7c 0e 01       	mov    %dil,0x1(%rsi,%rcx,1)
  408673:	48 8b 8c 24 80 00 00 	mov    0x80(%rsp),%rcx
  40867a:	00 
  40867b:	89 94 24 90 00 00 00 	mov    %edx,0x90(%rsp)
        while ((*col_num_cards) == 0)
  408682:	0f 84 bb f9 ff ff    	je     408043 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x2f3>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408688:	41 83 fb 08          	cmp    $0x8,%r11d
  40868c:	0f 85 ac fe ff ff    	jne    40853e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7ee>
  408692:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  408699:	00 00 00 00 
  40869d:	0f 1f 00             	nopl   (%rax)
  4086a0:	45 31 db             	xor    %r11d,%r11d
  4086a3:	e9 70 ff ff ff       	jmpq   408618 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x8c8>
        if (fcs_state_col_is_empty(state, ret))
  4086a8:	41 b9 07 00 00 00    	mov    $0x7,%r9d
  4086ae:	41 ba 07 00 00 00    	mov    $0x7,%r10d
  4086b4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4086bb:	00 00 00 00 
  4086bf:	90                   	nop
  4086c0:	45 8d 59 01          	lea    0x1(%r9),%r11d
  4086c4:	e9 5c ff ff ff       	jmpq   408625 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x8d5>
  4086c9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  4086d0:	4a 8d 3c d0          	lea    (%rax,%r10,8),%rdi
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4086d4:	44 0f ab c9          	bts    %r9d,%ecx
  4086d8:	41 c1 e1 07          	shl    $0x7,%r9d
  4086dc:	89 4e 14             	mov    %ecx,0x14(%rsi)
  4086df:	48 8b 37             	mov    (%rdi),%rsi
  4086e2:	4d 63 c9             	movslq %r9d,%r9
  4086e5:	48 89 7c 24 58       	mov    %rdi,0x58(%rsp)
  4086ea:	4c 03 4c 24 60       	add    0x60(%rsp),%r9
  4086ef:	0f be 0e             	movsbl (%rsi),%ecx
  4086f2:	83 c1 01             	add    $0x1,%ecx
  4086f5:	48 63 c9             	movslq %ecx,%rcx
  4086f8:	48 83 f9 08          	cmp    $0x8,%rcx
  4086fc:	73 62                	jae    408760 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa10>
  4086fe:	f6 c1 04             	test   $0x4,%cl
  408701:	0f 85 d2 00 00 00    	jne    4087d9 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa89>
  408707:	48 85 c9             	test   %rcx,%rcx
  40870a:	74 0f                	je     40871b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9cb>
  40870c:	0f b6 3e             	movzbl (%rsi),%edi
  40870f:	41 88 39             	mov    %dil,(%r9)
  408712:	f6 c1 02             	test   $0x2,%cl
  408715:	0f 85 0d 01 00 00    	jne    408828 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xad8>
  40871b:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  408720:	4c 89 0f             	mov    %r9,(%rdi)
  408723:	e9 12 ff ff ff       	jmpq   40863a <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x8ea>
  408728:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40872f:	00 
  408730:	4d 89 ee             	mov    %r13,%r14
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  408733:	83 44 24 28 01       	addl   $0x1,0x28(%rsp)
  408738:	8b 44 24 28          	mov    0x28(%rsp),%eax
  40873c:	48 83 6c 24 50 80    	subq   $0xffffffffffffff80,0x50(%rsp)
  408742:	83 f8 08             	cmp    $0x8,%eax
  408745:	0f 85 65 f6 ff ff    	jne    407db0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x60>
}
  40874b:	48 81 c4 a8 00 00 00 	add    $0xa8,%rsp
  408752:	5b                   	pop    %rbx
  408753:	5d                   	pop    %rbp
  408754:	41 5c                	pop    %r12
  408756:	41 5d                	pop    %r13
  408758:	41 5e                	pop    %r14
  40875a:	41 5f                	pop    %r15
  40875c:	c3                   	retq   
  40875d:	0f 1f 00             	nopl   (%rax)
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408760:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  408765:	49 89 7c 09 f8       	mov    %rdi,-0x8(%r9,%rcx,1)
  40876a:	48 83 e9 01          	sub    $0x1,%rcx
  40876e:	4c 89 cf             	mov    %r9,%rdi
  408771:	48 c1 e9 03          	shr    $0x3,%rcx
  408775:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  408778:	eb a1                	jmp    40871b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9cb>
  40877a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  408780:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  408785:	48 89 7c 08 f8       	mov    %rdi,-0x8(%rax,%rcx,1)
  40878a:	48 83 e9 01          	sub    $0x1,%rcx
  40878e:	48 89 c7             	mov    %rax,%rdi
  408791:	48 c1 e9 03          	shr    $0x3,%rcx
  408795:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  408798:	e9 62 fd ff ff       	jmpq   4084ff <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7af>
        if (fcs_state_col_is_empty(state, ret))
  40879d:	4d 63 c3             	movslq %r11d,%r8
  4087a0:	41 83 c3 01          	add    $0x1,%r11d
  4087a4:	4c 89 c0             	mov    %r8,%rax
  4087a7:	e9 7b fc ff ff       	jmpq   408427 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x6d7>
  4087ac:	4d 63 d3             	movslq %r11d,%r10
  4087af:	41 83 c3 01          	add    $0x1,%r11d
  4087b3:	4d 89 d1             	mov    %r10,%r9
  4087b6:	e9 6a fe ff ff       	jmpq   408625 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x8d5>
                my_copy_stack(ds);
  4087bb:	8b 16                	mov    (%rsi),%edx
  4087bd:	48 8b 7c 24 50       	mov    0x50(%rsp),%rdi
  4087c2:	89 17                	mov    %edx,(%rdi)
  4087c4:	8b 54 06 fc          	mov    -0x4(%rsi,%rax,1),%edx
  4087c8:	89 54 07 fc          	mov    %edx,-0x4(%rdi,%rax,1)
  4087cc:	48 8b 94 24 80 00 00 	mov    0x80(%rsp),%rdx
  4087d3:	00 
  4087d4:	e9 13 f9 ff ff       	jmpq   4080ec <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x39c>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4087d9:	8b 3e                	mov    (%rsi),%edi
  4087db:	41 89 39             	mov    %edi,(%r9)
  4087de:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  4087e2:	41 89 74 09 fc       	mov    %esi,-0x4(%r9,%rcx,1)
  4087e7:	e9 2f ff ff ff       	jmpq   40871b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9cb>
  4087ec:	8b 3e                	mov    (%rsi),%edi
  4087ee:	89 38                	mov    %edi,(%rax)
  4087f0:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  4087f4:	89 74 08 fc          	mov    %esi,-0x4(%rax,%rcx,1)
  4087f8:	e9 02 fd ff ff       	jmpq   4084ff <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7af>
                my_copy_stack(ds);
  4087fd:	0f b7 54 06 fe       	movzwl -0x2(%rsi,%rax,1),%edx
  408802:	48 8b 7c 24 50       	mov    0x50(%rsp),%rdi
  408807:	66 89 54 07 fe       	mov    %dx,-0x2(%rdi,%rax,1)
  40880c:	48 8b 94 24 80 00 00 	mov    0x80(%rsp),%rdx
  408813:	00 
  408814:	e9 d3 f8 ff ff       	jmpq   4080ec <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x39c>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408819:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  40881e:	66 89 74 08 fe       	mov    %si,-0x2(%rax,%rcx,1)
  408823:	e9 d7 fc ff ff       	jmpq   4084ff <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7af>
  408828:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  40882d:	66 41 89 74 09 fe    	mov    %si,-0x2(%r9,%rcx,1)
  408833:	e9 e3 fe ff ff       	jmpq   40871b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9cb>
  408838:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40883f:	00 

0000000000408840 <fc_solve_sfs_move_non_top_stack_cards_to_founds>:
{
  408840:	41 57                	push   %r15
    return -1;
  408842:	49 89 c9             	mov    %rcx,%r9
  408845:	49 89 f7             	mov    %rsi,%r15
{
  408848:	41 56                	push   %r14
  40884a:	41 55                	push   %r13
    const_AUTO(num_vacant_slots_plus_1, num_vacant_slots + 1);
  40884c:	45 31 ed             	xor    %r13d,%r13d
{
  40884f:	41 54                	push   %r12
  408851:	55                   	push   %rbp
  408852:	53                   	push   %rbx
  408853:	48 83 ec 78          	sub    $0x78,%rsp
    tests_define_accessors();
  408857:	48 8b 07             	mov    (%rdi),%rax
{
  40885a:	48 89 54 24 20       	mov    %rdx,0x20(%rsp)
    return -1;
  40885f:	48 89 7c 24 08       	mov    %rdi,0x8(%rsp)
    tests_define_accessors();
  408864:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
    const size_t derived_start_idx = derived_states_list->num_states;
  408869:	48 8b 01             	mov    (%rcx),%rax
  40886c:	48 89 04 24          	mov    %rax,(%rsp)
    return (soft_thread->num_vacant_freecells +
  408870:	0f b6 87 e4 01 00 00 	movzbl 0x1e4(%rdi),%eax
  408877:	02 87 e3 01 00 00    	add    0x1e3(%rdi),%al
    const_AUTO(num_vacant_slots_plus_1, num_vacant_slots + 1);
  40887d:	0f b6 c0             	movzbl %al,%eax
  408880:	83 c0 01             	add    $0x1,%eax
  408883:	89 44 24 14          	mov    %eax,0x14(%rsp)
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  408887:	4b 8b 0c ef          	mov    (%r15,%r13,8),%rcx
  40888b:	b8 00 00 00 00       	mov    $0x0,%eax
  408890:	45 89 ea             	mov    %r13d,%r10d
        const int cards_num = fcs_col_len(col);
  408893:	48 0f be 29          	movsbq (%rcx),%rbp
        for (int c = cards_num - 2; c >= c_bottom; c--)
  408897:	8d 75 fe             	lea    -0x2(%rbp),%esi
  40889a:	89 ef                	mov    %ebp,%edi
  40889c:	2b 7c 24 14          	sub    0x14(%rsp),%edi
        const int cards_num = fcs_col_len(col);
  4088a0:	48 89 ea             	mov    %rbp,%rdx
  4088a3:	0f 48 f8             	cmovs  %eax,%edi
        for (int c = cards_num - 2; c >= c_bottom; c--)
  4088a6:	39 fe                	cmp    %edi,%esi
  4088a8:	0f 8c bf 01 00 00    	jl     408a6d <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x22d>
            const fcs_card card = fcs_col_get_card(col, c);
  4088ae:	48 63 c6             	movslq %esi,%rax
  4088b1:	0f b6 5c 01 01       	movzbl 0x1(%rcx,%rax,1),%ebx
                const int dest_found = deck * 4 + fcs_card_suit(card);
  4088b6:	41 89 de             	mov    %ebx,%r14d
                    fcs_card_rank(card) - 1)
  4088b9:	c0 fb 02             	sar    $0x2,%bl
                const int dest_found = deck * 4 + fcs_card_suit(card);
  4088bc:	41 83 e6 03          	and    $0x3,%r14d
                    fcs_card_rank(card) - 1)
  4088c0:	0f be db             	movsbl %bl,%ebx
  4088c3:	44 8d 5b ff          	lea    -0x1(%rbx),%r11d
                if (fcs_foundation_value(state, dest_found) !=
  4088c7:	4d 63 e6             	movslq %r14d,%r12
  4088ca:	47 0f be 44 27 44    	movsbl 0x44(%r15,%r12,1),%r8d
  4088d0:	45 39 c3             	cmp    %r8d,%r11d
  4088d3:	0f 84 57 05 00 00    	je     408e30 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5f0>
  4088d9:	48 83 ea 02          	sub    $0x2,%rdx
  4088dd:	29 fe                	sub    %edi,%esi
  4088df:	48 29 f2             	sub    %rsi,%rdx
  4088e2:	41 89 c0             	mov    %eax,%r8d
        for (int c = cards_num - 2; c >= c_bottom; c--)
  4088e5:	48 39 d0             	cmp    %rdx,%rax
  4088e8:	0f 84 7f 01 00 00    	je     408a6d <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x22d>
            const fcs_card card = fcs_col_get_card(col, c);
  4088ee:	0f b6 34 01          	movzbl (%rcx,%rax,1),%esi
                const int dest_found = deck * 4 + fcs_card_suit(card);
  4088f2:	48 83 e8 01          	sub    $0x1,%rax
  4088f6:	41 89 f6             	mov    %esi,%r14d
                    fcs_card_rank(card) - 1)
  4088f9:	40 c0 fe 02          	sar    $0x2,%sil
                const int dest_found = deck * 4 + fcs_card_suit(card);
  4088fd:	41 83 e6 03          	and    $0x3,%r14d
                    fcs_card_rank(card) - 1)
  408901:	40 0f be de          	movsbl %sil,%ebx
  408905:	8d 73 ff             	lea    -0x1(%rbx),%esi
                if (fcs_foundation_value(state, dest_found) !=
  408908:	4d 63 e6             	movslq %r14d,%r12
  40890b:	43 0f be 7c 27 44    	movsbl 0x44(%r15,%r12,1),%edi
  408911:	39 f7                	cmp    %esi,%edi
  408913:	75 cd                	jne    4088e2 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0xa2>
                sfs_check_state_begin();
  408915:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  40891a:	4c 89 fa             	mov    %r15,%rdx
  40891d:	4c 89 4c 24 38       	mov    %r9,0x38(%rsp)
  408922:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  408927:	48 8d 74 24 50       	lea    0x50(%rsp),%rsi
  40892c:	44 89 54 24 30       	mov    %r10d,0x30(%rsp)
  408931:	44 89 44 24 28       	mov    %r8d,0x28(%rsp)
  408936:	e8 e5 90 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
                my_copy_stack(stack_idx);
  40893b:	48 8b 54 24 58       	mov    0x58(%rsp),%rdx
  408940:	44 8b 54 24 30       	mov    0x30(%rsp),%r10d
  408945:	44 8b 44 24 28       	mov    0x28(%rsp),%r8d
  40894a:	4c 8b 4c 24 38       	mov    0x38(%rsp),%r9
  40894f:	8b 42 14             	mov    0x14(%rdx),%eax
  408952:	44 0f a3 d0          	bt     %r10d,%eax
  408956:	0f 83 94 01 00 00    	jae    408af0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x2b0>
  40895c:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  408961:	4d 63 da             	movslq %r10d,%r11
                empty_two_cols_from_new_state(soft_thread,
  408964:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
  408969:	89 ea                	mov    %ebp,%edx
                const int cols_indexes[3] = {stack_idx, -1, -1};
  40896b:	44 89 54 24 44       	mov    %r10d,0x44(%rsp)
  408970:	48 c7 44 24 48 ff ff 	movq   $0xffffffffffffffff,0x48(%rsp)
  408977:	ff ff 
                empty_two_cols_from_new_state(soft_thread,
  408979:	44 29 c2             	sub    %r8d,%edx
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  40897c:	89 54 24 60          	mov    %edx,0x60(%rsp)
                empty_two_cols_from_new_state(soft_thread,
  408980:	48 8b 3f             	mov    (%rdi),%rdi
  408983:	48 89 7c 24 28       	mov    %rdi,0x28(%rsp)
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  408988:	48 bf 00 00 00 00 ff 	movabs $0xffffffff00000000,%rdi
  40898f:	ff ff ff 
  408992:	48 89 7c 24 64       	mov    %rdi,0x64(%rsp)
            while ((*col_num_cards) == 0)
  408997:	0f 85 03 02 00 00    	jne    408ba0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x360>
  40899d:	0f 1f 00             	nopl   (%rax)
  4089a0:	48 8b 4c 24 50       	mov    0x50(%rsp),%rcx
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  4089a5:	4a 8b 14 d9          	mov    (%rcx,%r11,8),%rdx
                    (((fcs_card_rank(card)) << 8) | fcs_card_suit(card));
  4089a9:	c1 e3 08             	shl    $0x8,%ebx
  4089ac:	4c 89 4c 24 28       	mov    %r9,0x28(%rsp)
    if (!fc_solve_check_and_add_state(
  4089b1:	48 8d 74 24 50       	lea    0x50(%rsp),%rsi
                state_context_value =
  4089b6:	41 09 de             	or     %ebx,%r14d
    fcs_col_pop_top(col);
  4089b9:	0f b6 02             	movzbl (%rdx),%eax
  4089bc:	83 e8 01             	sub    $0x1,%eax
  4089bf:	88 02                	mov    %al,(%rdx)
  4089c1:	48 0f be c0          	movsbq %al,%rax
  4089c5:	c6 44 02 01 00       	movb   $0x0,0x1(%rdx,%rax,1)
                fcs_increment_foundation(new_state_key, dest_found);
  4089ca:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  4089cf:	48 8d 54 24 60       	lea    0x60(%rsp),%rdx
  4089d4:	42 80 44 20 44 01    	addb   $0x1,0x44(%rax,%r12,1)
    const_SLOT(hard_thread, soft_thread);
  4089da:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  4089df:	48 8b 18             	mov    (%rax),%rbx
    if (!fc_solve_check_and_add_state(
  4089e2:	48 89 df             	mov    %rbx,%rdi
  4089e5:	e8 86 91 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  4089ea:	4c 8b 4c 24 28       	mov    0x28(%rsp),%r9
  4089ef:	84 c0                	test   %al,%al
  4089f1:	75 3d                	jne    408a30 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x1f0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  4089f3:	80 bb 18 05 00 00 00 	cmpb   $0x0,0x518(%rbx)
  4089fa:	0f 84 40 04 00 00    	je     408e40 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x600>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  408a00:	48 8b 93 b0 00 00 00 	mov    0xb0(%rbx),%rdx
  408a07:	48 8b 44 24 58       	mov    0x58(%rsp),%rax
  408a0c:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  408a0f:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  408a14:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  408a1b:	48 8b 5c 24 60       	mov    0x60(%rsp),%rbx
    return (fcs_collectible_state *)(s->key);
  408a20:	eb 13                	jmp    408a35 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x1f5>
  408a22:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  408a29:	00 00 00 00 
  408a2d:	0f 1f 00             	nopl   (%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  408a30:	48 8b 5c 24 50       	mov    0x50(%rsp),%rbx
    if ((!((list->num_states + (list->states != NULL)) &
  408a35:	49 8b 79 08          	mov    0x8(%r9),%rdi
  408a39:	31 d2                	xor    %edx,%edx
  408a3b:	49 8b 01             	mov    (%r9),%rax
  408a3e:	48 85 ff             	test   %rdi,%rdi
  408a41:	0f 95 c2             	setne  %dl
  408a44:	48 01 c2             	add    %rax,%rdx
  408a47:	f6 c2 0f             	test   $0xf,%dl
  408a4a:	0f 84 20 01 00 00    	je     408b70 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x330>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  408a50:	48 8d 50 01          	lea    0x1(%rax),%rdx
  408a54:	48 c1 e0 04          	shl    $0x4,%rax
  408a58:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  408a5c:	48 01 f8             	add    %rdi,%rax
  408a5f:	49 89 11             	mov    %rdx,(%r9)
  408a62:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  408a66:	48 89 18             	mov    %rbx,(%rax)
  408a69:	44 89 70 08          	mov    %r14d,0x8(%rax)
    end_loop:;
  408a6d:	49 83 c5 01          	add    $0x1,%r13
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  408a71:	49 83 fd 08          	cmp    $0x8,%r13
  408a75:	0f 85 0c fe ff ff    	jne    408887 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x47>
    var_AUTO(start, d->states + derived_start_idx);
  408a7b:	48 8b 0c 24          	mov    (%rsp),%rcx
    sort_derived_states(derived_states_list, derived_start_idx);
  408a7f:	49 8b 41 08          	mov    0x8(%r9),%rax
    const_AUTO(limit, d->states + d->num_states);
  408a83:	49 8b 31             	mov    (%r9),%rsi
    var_AUTO(start, d->states + derived_start_idx);
  408a86:	48 c1 e1 04          	shl    $0x4,%rcx
  408a8a:	48 01 c1             	add    %rax,%rcx
    for (var_AUTO(b, start + 1); b < limit; b++)
  408a8d:	48 8d 51 10          	lea    0x10(%rcx),%rdx
    const_AUTO(limit, d->states + d->num_states);
  408a91:	48 c1 e6 04          	shl    $0x4,%rsi
  408a95:	48 01 c6             	add    %rax,%rsi
    for (var_AUTO(b, start + 1); b < limit; b++)
  408a98:	48 39 d6             	cmp    %rdx,%rsi
  408a9b:	76 40                	jbe    408add <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x29d>
  408a9d:	0f 1f 00             	nopl   (%rax)
        for (var_AUTO(c, b); (c > start) && (c[0].context.i < c[-1].context.i);
  408aa0:	8b 42 08             	mov    0x8(%rdx),%eax
  408aa3:	39 42 f8             	cmp    %eax,-0x8(%rdx)
  408aa6:	7e 2c                	jle    408ad4 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x294>
  408aa8:	48 89 d0             	mov    %rdx,%rax
  408aab:	eb 0b                	jmp    408ab8 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x278>
  408aad:	0f 1f 00             	nopl   (%rax)
  408ab0:	8b 58 08             	mov    0x8(%rax),%ebx
  408ab3:	39 58 f8             	cmp    %ebx,-0x8(%rax)
  408ab6:	7e 1c                	jle    408ad4 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x294>
            const_AUTO(swap_temp, c[-1]);
  408ab8:	c5 fa 6f 40 f0       	vmovdqu -0x10(%rax),%xmm0
             c--)
  408abd:	48 83 e8 10          	sub    $0x10,%rax
            c[-1] = c[0];
  408ac1:	c5 fa 6f 48 10       	vmovdqu 0x10(%rax),%xmm1
            c[0] = swap_temp;
  408ac6:	c5 f8 11 40 10       	vmovups %xmm0,0x10(%rax)
            c[-1] = c[0];
  408acb:	c5 f8 11 08          	vmovups %xmm1,(%rax)
        for (var_AUTO(c, b); (c > start) && (c[0].context.i < c[-1].context.i);
  408acf:	48 39 c1             	cmp    %rax,%rcx
  408ad2:	72 dc                	jb     408ab0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x270>
    for (var_AUTO(b, start + 1); b < limit; b++)
  408ad4:	48 83 c2 10          	add    $0x10,%rdx
  408ad8:	48 39 d6             	cmp    %rdx,%rsi
  408adb:	77 c3                	ja     408aa0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x260>
}
  408add:	48 83 c4 78          	add    $0x78,%rsp
  408ae1:	5b                   	pop    %rbx
  408ae2:	5d                   	pop    %rbp
  408ae3:	41 5c                	pop    %r12
  408ae5:	41 5d                	pop    %r13
  408ae7:	41 5e                	pop    %r14
  408ae9:	41 5f                	pop    %r15
  408aeb:	c3                   	retq   
  408aec:	0f 1f 40 00          	nopl   0x0(%rax)
                my_copy_stack(stack_idx);
  408af0:	44 0f ab d0          	bts    %r10d,%eax
  408af4:	4d 63 da             	movslq %r10d,%r11
  408af7:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  408afc:	89 42 14             	mov    %eax,0x14(%rdx)
  408aff:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  408b04:	4c 89 ea             	mov    %r13,%rdx
  408b07:	48 c1 e2 07          	shl    $0x7,%rdx
  408b0b:	48 8d 94 17 00 01 00 	lea    0x100(%rdi,%rdx,1),%rdx
  408b12:	00 
  408b13:	4a 8b 34 d8          	mov    (%rax,%r11,8),%rsi
  408b17:	0f be 0e             	movsbl (%rsi),%ecx
  408b1a:	83 c1 01             	add    $0x1,%ecx
  408b1d:	48 63 c9             	movslq %ecx,%rcx
  408b20:	48 83 f9 08          	cmp    $0x8,%rcx
  408b24:	0f 83 56 03 00 00    	jae    408e80 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x640>
  408b2a:	f6 c1 04             	test   $0x4,%cl
  408b2d:	0f 85 af 03 00 00    	jne    408ee2 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x6a2>
  408b33:	48 85 c9             	test   %rcx,%rcx
  408b36:	74 28                	je     408b60 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x320>
  408b38:	0f b6 06             	movzbl (%rsi),%eax
  408b3b:	88 02                	mov    %al,(%rdx)
  408b3d:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  408b42:	f6 c1 02             	test   $0x2,%cl
  408b45:	74 19                	je     408b60 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x320>
  408b47:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  408b4c:	66 89 44 0a fe       	mov    %ax,-0x2(%rdx,%rcx,1)
  408b51:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  408b56:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  408b5d:	00 00 00 
  408b60:	4a 89 14 d8          	mov    %rdx,(%rax,%r11,8)
  408b64:	e9 fb fd ff ff       	jmpq   408964 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x124>
  408b69:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  408b70:	48 8d 72 10          	lea    0x10(%rdx),%rsi
  408b74:	4c 89 4c 24 28       	mov    %r9,0x28(%rsp)
  408b79:	48 c1 e6 04          	shl    $0x4,%rsi
  408b7d:	e8 ee 85 ff ff       	callq  401170 <realloc@plt>
        list->states =
  408b82:	4c 8b 4c 24 28       	mov    0x28(%rsp),%r9
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  408b87:	48 89 c7             	mov    %rax,%rdi
        list->states =
  408b8a:	49 89 41 08          	mov    %rax,0x8(%r9)
  408b8e:	49 8b 01             	mov    (%r9),%rax
  408b91:	e9 ba fe ff ff       	jmpq   408a50 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x210>
  408b96:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  408b9d:	00 00 00 
        int dest_fc_idx = 0;
  408ba0:	31 ff                	xor    %edi,%edi
            while ((*col_num_cards) == 0)
  408ba2:	31 f6                	xor    %esi,%esi
  408ba4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  408bab:	00 00 00 00 
  408baf:	90                   	nop
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408bb0:	4c 63 c7             	movslq %edi,%r8
  408bb3:	42 80 7c 00 40 00    	cmpb   $0x0,0x40(%rax,%r8,1)
  408bb9:	0f 84 23 02 00 00    	je     408de2 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5a2>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408bbf:	8d 4f 01             	lea    0x1(%rdi),%ecx
  408bc2:	83 f9 04             	cmp    $0x4,%ecx
  408bc5:	74 34                	je     408bfb <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x3bb>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408bc7:	4c 63 c1             	movslq %ecx,%r8
  408bca:	42 80 7c 00 40 00    	cmpb   $0x0,0x40(%rax,%r8,1)
  408bd0:	0f 84 0a 02 00 00    	je     408de0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5a0>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408bd6:	8d 4f 02             	lea    0x2(%rdi),%ecx
  408bd9:	83 f9 04             	cmp    $0x4,%ecx
  408bdc:	74 1d                	je     408bfb <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x3bb>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408bde:	4c 63 c1             	movslq %ecx,%r8
  408be1:	42 80 7c 00 40 00    	cmpb   $0x0,0x40(%rax,%r8,1)
  408be7:	0f 84 f3 01 00 00    	je     408de0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5a0>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408bed:	85 ff                	test   %edi,%edi
  408bef:	75 0a                	jne    408bfb <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x3bb>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408bf1:	80 78 43 00          	cmpb   $0x0,0x43(%rax)
  408bf5:	0f 84 75 02 00 00    	je     408e70 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x630>
  408bfb:	40 84 f6             	test   %sil,%sil
  408bfe:	74 04                	je     408c04 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x3c4>
  408c00:	89 54 24 60          	mov    %edx,0x60(%rsp)
    while ((*col_num_cards) == 0)
  408c04:	85 d2                	test   %edx,%edx
  408c06:	0f 84 94 fd ff ff    	je     4089a0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x160>
    char *const indirect_stacks_buffer =
  408c0c:	48 8b 7c 24 28       	mov    0x28(%rsp),%rdi
    int put_cards_in_col_idx = 0;
  408c11:	31 ed                	xor    %ebp,%ebp
  408c13:	48 8b 4c 24 50       	mov    0x50(%rsp),%rcx
    char *const indirect_stacks_buffer =
  408c18:	48 81 c7 00 01 00 00 	add    $0x100,%rdi
  408c1f:	48 89 7c 24 30       	mov    %rdi,0x30(%rsp)
  408c24:	eb 52                	jmp    408c78 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x438>
  408c26:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  408c2d:	00 00 00 
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408c30:	4a 8b 34 d8          	mov    (%rax,%r11,8),%rsi
    fcs_col_pop_card(col, ret);
  408c34:	0f be 3e             	movsbl (%rsi),%edi
  408c37:	89 f9                	mov    %edi,%ecx
  408c39:	83 ef 01             	sub    $0x1,%edi
  408c3c:	83 e9 01             	sub    $0x1,%ecx
  408c3f:	48 63 ff             	movslq %edi,%rdi
        --(*col_num_cards);
  408c42:	83 ea 01             	sub    $0x1,%edx
  408c45:	0f b6 7c 3e 01       	movzbl 0x1(%rsi,%rdi,1),%edi
  408c4a:	88 0e                	mov    %cl,(%rsi)
  408c4c:	48 0f be c9          	movsbq %cl,%rcx
  408c50:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408c55:	4a 8b 34 c0          	mov    (%rax,%r8,8),%rsi
    fcs_col_push_card(col, card);
  408c59:	48 0f be 0e          	movsbq (%rsi),%rcx
  408c5d:	44 8d 41 01          	lea    0x1(%rcx),%r8d
  408c61:	44 88 06             	mov    %r8b,(%rsi)
  408c64:	40 88 7c 0e 01       	mov    %dil,0x1(%rsi,%rcx,1)
  408c69:	48 8b 4c 24 50       	mov    0x50(%rsp),%rcx
  408c6e:	89 54 24 60          	mov    %edx,0x60(%rsp)
        while ((*col_num_cards) == 0)
  408c72:	0f 84 2d fd ff ff    	je     4089a5 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x165>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408c78:	83 fd 08             	cmp    $0x8,%ebp
  408c7b:	0f 84 2f 02 00 00    	je     408eb0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x670>
        if (fcs_state_col_is_empty(state, ret))
  408c81:	48 63 f5             	movslq %ebp,%rsi
  408c84:	48 8b 34 f1          	mov    (%rcx,%rsi,8),%rsi
  408c88:	80 3e 00             	cmpb   $0x0,(%rsi)
  408c8b:	0f 84 43 02 00 00    	je     408ed4 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x694>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408c91:	44 8d 55 01          	lea    0x1(%rbp),%r10d
  408c95:	41 83 fa 08          	cmp    $0x8,%r10d
  408c99:	0f 84 11 02 00 00    	je     408eb0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x670>
        if (fcs_state_col_is_empty(state, ret))
  408c9f:	4d 63 c2             	movslq %r10d,%r8
  408ca2:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  408ca6:	80 3e 00             	cmpb   $0x0,(%rsi)
  408ca9:	0f 84 b1 01 00 00    	je     408e60 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x620>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408caf:	44 8d 55 02          	lea    0x2(%rbp),%r10d
  408cb3:	41 83 fa 08          	cmp    $0x8,%r10d
  408cb7:	0f 84 f3 01 00 00    	je     408eb0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x670>
        if (fcs_state_col_is_empty(state, ret))
  408cbd:	4d 63 c2             	movslq %r10d,%r8
  408cc0:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  408cc4:	80 3e 00             	cmpb   $0x0,(%rsi)
  408cc7:	0f 84 93 01 00 00    	je     408e60 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x620>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408ccd:	44 8d 55 03          	lea    0x3(%rbp),%r10d
  408cd1:	41 83 fa 08          	cmp    $0x8,%r10d
  408cd5:	0f 84 d5 01 00 00    	je     408eb0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x670>
        if (fcs_state_col_is_empty(state, ret))
  408cdb:	4d 63 c2             	movslq %r10d,%r8
  408cde:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  408ce2:	80 3e 00             	cmpb   $0x0,(%rsi)
  408ce5:	0f 84 75 01 00 00    	je     408e60 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x620>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408ceb:	44 8d 55 04          	lea    0x4(%rbp),%r10d
  408cef:	41 83 fa 08          	cmp    $0x8,%r10d
  408cf3:	0f 84 b7 01 00 00    	je     408eb0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x670>
        if (fcs_state_col_is_empty(state, ret))
  408cf9:	4d 63 c2             	movslq %r10d,%r8
  408cfc:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  408d00:	80 3e 00             	cmpb   $0x0,(%rsi)
  408d03:	0f 84 57 01 00 00    	je     408e60 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x620>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408d09:	44 8d 55 05          	lea    0x5(%rbp),%r10d
  408d0d:	41 83 fa 08          	cmp    $0x8,%r10d
  408d11:	0f 84 99 01 00 00    	je     408eb0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x670>
        if (fcs_state_col_is_empty(state, ret))
  408d17:	4d 63 c2             	movslq %r10d,%r8
  408d1a:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  408d1e:	80 3e 00             	cmpb   $0x0,(%rsi)
  408d21:	0f 84 39 01 00 00    	je     408e60 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x620>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408d27:	44 8d 55 06          	lea    0x6(%rbp),%r10d
  408d2b:	41 83 fa 08          	cmp    $0x8,%r10d
  408d2f:	0f 84 7b 01 00 00    	je     408eb0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x670>
        if (fcs_state_col_is_empty(state, ret))
  408d35:	4d 63 c2             	movslq %r10d,%r8
  408d38:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  408d3c:	80 3e 00             	cmpb   $0x0,(%rsi)
  408d3f:	0f 84 1b 01 00 00    	je     408e60 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x620>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408d45:	85 ed                	test   %ebp,%ebp
  408d47:	0f 85 63 01 00 00    	jne    408eb0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x670>
        if (fcs_state_col_is_empty(state, ret))
  408d4d:	48 8b 49 38          	mov    0x38(%rcx),%rcx
  408d51:	80 39 00             	cmpb   $0x0,(%rcx)
  408d54:	0f 84 f9 00 00 00    	je     408e53 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x613>
    return -1;
  408d5a:	41 ba ff ff ff ff    	mov    $0xffffffff,%r10d
  408d60:	49 c7 c0 ff ff ff ff 	mov    $0xffffffffffffffff,%r8
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408d67:	48 8b 74 24 58       	mov    0x58(%rsp),%rsi
  408d6c:	8b 4e 14             	mov    0x14(%rsi),%ecx
  408d6f:	44 0f a3 d1          	bt     %r10d,%ecx
  408d73:	0f 82 b7 fe ff ff    	jb     408c30 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x3f0>
  408d79:	4a 8d 3c c0          	lea    (%rax,%r8,8),%rdi
  408d7d:	44 0f ab d1          	bts    %r10d,%ecx
  408d81:	41 c1 e2 07          	shl    $0x7,%r10d
  408d85:	89 4e 14             	mov    %ecx,0x14(%rsi)
  408d88:	48 8b 37             	mov    (%rdi),%rsi
  408d8b:	4d 63 d2             	movslq %r10d,%r10
  408d8e:	48 89 7c 24 28       	mov    %rdi,0x28(%rsp)
  408d93:	4c 03 54 24 30       	add    0x30(%rsp),%r10
  408d98:	0f be 0e             	movsbl (%rsi),%ecx
  408d9b:	83 c1 01             	add    $0x1,%ecx
  408d9e:	48 63 c9             	movslq %ecx,%rcx
  408da1:	48 83 f9 08          	cmp    $0x8,%rcx
  408da5:	0f 83 0c 01 00 00    	jae    408eb7 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x677>
  408dab:	f6 c1 04             	test   $0x4,%cl
  408dae:	0f 85 44 01 00 00    	jne    408ef8 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x6b8>
  408db4:	48 85 c9             	test   %rcx,%rcx
  408db7:	74 0f                	je     408dc8 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x588>
  408db9:	0f b6 3e             	movzbl (%rsi),%edi
  408dbc:	41 88 3a             	mov    %dil,(%r10)
  408dbf:	f6 c1 02             	test   $0x2,%cl
  408dc2:	0f 85 43 01 00 00    	jne    408f0b <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x6cb>
  408dc8:	48 8b 7c 24 28       	mov    0x28(%rsp),%rdi
  408dcd:	4c 89 17             	mov    %r10,(%rdi)
  408dd0:	e9 5b fe ff ff       	jmpq   408c30 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x3f0>
  408dd5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  408ddc:	00 00 00 00 
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408de0:	89 cf                	mov    %ecx,%edi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408de2:	4a 8b 34 d8          	mov    (%rax,%r11,8),%rsi
            ++dest_fc_idx;
  408de6:	83 c7 01             	add    $0x1,%edi
    fcs_col_pop_card(col, ret);
  408de9:	44 0f be 16          	movsbl (%rsi),%r10d
  408ded:	44 89 d1             	mov    %r10d,%ecx
  408df0:	41 83 ea 01          	sub    $0x1,%r10d
  408df4:	4d 63 d2             	movslq %r10d,%r10
  408df7:	83 e9 01             	sub    $0x1,%ecx
  408dfa:	46 0f b6 54 16 01    	movzbl 0x1(%rsi,%r10,1),%r10d
  408e00:	88 0e                	mov    %cl,(%rsi)
  408e02:	48 0f be c9          	movsbq %cl,%rcx
  408e06:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  408e0b:	46 88 54 00 40       	mov    %r10b,0x40(%rax,%r8,1)
            while ((*col_num_cards) == 0)
  408e10:	83 ea 01             	sub    $0x1,%edx
  408e13:	0f 84 87 fb ff ff    	je     4089a0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x160>
  408e19:	be 01 00 00 00       	mov    $0x1,%esi
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408e1e:	83 ff 04             	cmp    $0x4,%edi
  408e21:	0f 85 89 fd ff ff    	jne    408bb0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x370>
  408e27:	e9 d4 fd ff ff       	jmpq   408c00 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x3c0>
  408e2c:	0f 1f 40 00          	nopl   0x0(%rax)
  408e30:	44 8d 45 ff          	lea    -0x1(%rbp),%r8d
  408e34:	e9 dc fa ff ff       	jmpq   408915 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0xd5>
  408e39:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  408e40:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
  408e47:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
  408e4e:	e9 c8 fb ff ff       	jmpq   408a1b <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x1db>
        if (fcs_state_col_is_empty(state, ret))
  408e53:	41 ba 07 00 00 00    	mov    $0x7,%r10d
  408e59:	41 b8 07 00 00 00    	mov    $0x7,%r8d
  408e5f:	90                   	nop
  408e60:	41 8d 6a 01          	lea    0x1(%r10),%ebp
  408e64:	e9 fe fe ff ff       	jmpq   408d67 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x527>
  408e69:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408e70:	bf 03 00 00 00       	mov    $0x3,%edi
  408e75:	41 b8 03 00 00 00    	mov    $0x3,%r8d
  408e7b:	e9 62 ff ff ff       	jmpq   408de2 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5a2>
                my_copy_stack(stack_idx);
  408e80:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  408e85:	48 89 d7             	mov    %rdx,%rdi
  408e88:	48 89 44 0a f8       	mov    %rax,-0x8(%rdx,%rcx,1)
  408e8d:	48 83 e9 01          	sub    $0x1,%rcx
  408e91:	48 c1 e9 03          	shr    $0x3,%rcx
  408e95:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  408e98:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  408e9d:	e9 be fc ff ff       	jmpq   408b60 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x320>
  408ea2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  408ea9:	00 00 00 00 
  408ead:	0f 1f 00             	nopl   (%rax)
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408eb0:	31 ed                	xor    %ebp,%ebp
  408eb2:	e9 a3 fe ff ff       	jmpq   408d5a <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x51a>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408eb7:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  408ebc:	49 89 7c 0a f8       	mov    %rdi,-0x8(%r10,%rcx,1)
  408ec1:	48 83 e9 01          	sub    $0x1,%rcx
  408ec5:	4c 89 d7             	mov    %r10,%rdi
  408ec8:	48 c1 e9 03          	shr    $0x3,%rcx
  408ecc:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  408ecf:	e9 f4 fe ff ff       	jmpq   408dc8 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x588>
        if (fcs_state_col_is_empty(state, ret))
  408ed4:	4c 63 c5             	movslq %ebp,%r8
  408ed7:	83 c5 01             	add    $0x1,%ebp
  408eda:	4d 89 c2             	mov    %r8,%r10
  408edd:	e9 85 fe ff ff       	jmpq   408d67 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x527>
                my_copy_stack(stack_idx);
  408ee2:	8b 06                	mov    (%rsi),%eax
  408ee4:	89 02                	mov    %eax,(%rdx)
  408ee6:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  408eea:	89 44 0a fc          	mov    %eax,-0x4(%rdx,%rcx,1)
  408eee:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  408ef3:	e9 68 fc ff ff       	jmpq   408b60 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x320>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408ef8:	8b 3e                	mov    (%rsi),%edi
  408efa:	41 89 3a             	mov    %edi,(%r10)
  408efd:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  408f01:	41 89 74 0a fc       	mov    %esi,-0x4(%r10,%rcx,1)
  408f06:	e9 bd fe ff ff       	jmpq   408dc8 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x588>
  408f0b:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  408f10:	66 41 89 74 0a fe    	mov    %si,-0x2(%r10,%rcx,1)
  408f16:	e9 ad fe ff ff       	jmpq   408dc8 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x588>
  408f1b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

0000000000408f20 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks>:
{
  408f20:	41 57                	push   %r15
  408f22:	41 56                	push   %r14
  408f24:	41 55                	push   %r13
  408f26:	41 54                	push   %r12
  408f28:	55                   	push   %rbp
  408f29:	48 89 f5             	mov    %rsi,%rbp
  408f2c:	53                   	push   %rbx
  408f2d:	48 81 ec 88 00 00 00 	sub    $0x88,%rsp
    return (soft_thread->num_vacant_freecells +
  408f34:	0f b6 87 e3 01 00 00 	movzbl 0x1e3(%rdi),%eax
  408f3b:	02 87 e4 01 00 00    	add    0x1e4(%rdi),%al
{
  408f41:	48 89 7c 24 18       	mov    %rdi,0x18(%rsp)
    MOVE_FUNCS__define_common();
  408f46:	48 8b 1f             	mov    (%rdi),%rbx
{
  408f49:	48 89 54 24 30       	mov    %rdx,0x30(%rsp)
  408f4e:	48 89 4c 24 48       	mov    %rcx,0x48(%rsp)
    return (soft_thread->num_vacant_freecells +
  408f53:	88 44 24 26          	mov    %al,0x26(%rsp)
    if (soft_thread->super_method_type == FCS_SUPER_METHOD_DFS)
  408f57:	8b 47 20             	mov    0x20(%rdi),%eax
    MOVE_FUNCS__define_common();
  408f5a:	48 89 5c 24 28       	mov    %rbx,0x28(%rsp)
  408f5f:	48 81 c3 00 01 00 00 	add    $0x100,%rbx
  408f66:	48 89 5c 24 40       	mov    %rbx,0x40(%rsp)
        return (BEFS_M_VAR(soft_thread, befs_positions_by_rank));
  408f6b:	48 8d 5f 60          	lea    0x60(%rdi),%rbx
  408f6f:	48 89 5c 24 38       	mov    %rbx,0x38(%rsp)
    if (soft_thread->super_method_type == FCS_SUPER_METHOD_DFS)
  408f74:	85 c0                	test   %eax,%eax
  408f76:	75 15                	jne    408f8d <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x6d>
        return (DFS_VAR(soft_thread, soft_dfs_info)[DFS_VAR(soft_thread, depth)]
  408f78:	48 69 47 38 b0 00 00 	imul   $0xb0,0x38(%rdi),%rax
  408f7f:	00 
  408f80:	48 03 47 30          	add    0x30(%rdi),%rax
  408f84:	48 83 c0 40          	add    $0x40,%rax
  408f88:	48 89 44 24 38       	mov    %rax,0x38(%rsp)
{
  408f8d:	45 31 e4             	xor    %r12d,%r12d
    return -1;
  408f90:	4c 89 24 24          	mov    %r12,(%rsp)
  408f94:	48 8b 04 24          	mov    (%rsp),%rax
        const fcs_card src_card = fcs_freecell_card(state, fc);
  408f98:	44 0f b6 64 05 40    	movzbl 0x40(%rbp,%rax,1),%r12d
  408f9e:	89 44 24 20          	mov    %eax,0x20(%rsp)
        if (!(
  408fa2:	45 84 e4             	test   %r12b,%r12b
  408fa5:	74 0d                	je     408fb4 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x94>
    return fc_solve_is_king_buf[(size_t)card];
  408fa7:	49 0f be c4          	movsbq %r12b,%rax
  408fab:	80 b8 00 02 41 00 00 	cmpb   $0x0,0x410200(%rax)
  408fb2:	74 2c                	je     408fe0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0xc0>
  408fb4:	48 83 04 24 01       	addq   $0x1,(%rsp)
  408fb9:	48 8b 04 24          	mov    (%rsp),%rax
    for (int fc = 0; fc < LOCAL_FREECELLS_NUM; fc++)
  408fbd:	48 83 f8 04          	cmp    $0x4,%rax
  408fc1:	75 d1                	jne    408f94 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x74>
}
  408fc3:	48 81 c4 88 00 00 00 	add    $0x88,%rsp
  408fca:	5b                   	pop    %rbx
  408fcb:	5d                   	pop    %rbp
  408fcc:	41 5c                	pop    %r12
  408fce:	41 5d                	pop    %r13
  408fd0:	41 5e                	pop    %r14
  408fd2:	41 5f                	pop    %r15
  408fd4:	c3                   	retq   
  408fd5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  408fdc:	00 00 00 00 
        FCS_POS_IDX_TO_CHECK_START_LOOP(src_card)
  408fe0:	48 c1 e0 04          	shl    $0x4,%rax
  408fe4:	48 8b 54 24 38       	mov    0x38(%rsp),%rdx
  408fe9:	48 8b 98 40 02 41 00 	mov    0x410240(%rax),%rbx
  408ff0:	48 01 d3             	add    %rdx,%rbx
  408ff3:	48 03 90 48 02 41 00 	add    0x410248(%rax),%rdx
  408ffa:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  408fff:	48 39 d3             	cmp    %rdx,%rbx
  409002:	73 b0                	jae    408fb4 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x94>
            sfs_check_state_begin();
  409004:	49 89 df             	mov    %rbx,%r15
  409007:	44 88 64 24 27       	mov    %r12b,0x27(%rsp)
  40900c:	4c 8b 74 24 48       	mov    0x48(%rsp),%r14
  409011:	eb 7f                	jmp    409092 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x172>
  409013:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40901a:	00 00 00 00 
  40901e:	66 90                	xchg   %ax,%ax
        if (HT_FIELD(hard_thread, allocated_from_list))
  409020:	80 bb 18 05 00 00 00 	cmpb   $0x0,0x518(%rbx)
  409027:	0f 84 e3 03 00 00    	je     409410 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4f0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  40902d:	48 8b 93 b0 00 00 00 	mov    0xb0(%rbx),%rdx
  409034:	48 8b 44 24 68       	mov    0x68(%rsp),%rax
  409039:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  40903c:	48 8b 44 24 60       	mov    0x60(%rsp),%rax
  409041:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  409048:	48 8b 5c 24 70       	mov    0x70(%rsp),%rbx
    if ((!((list->num_states + (list->states != NULL)) &
  40904d:	49 8b 46 08          	mov    0x8(%r14),%rax
  409051:	31 f6                	xor    %esi,%esi
  409053:	49 8b 3e             	mov    (%r14),%rdi
  409056:	48 85 c0             	test   %rax,%rax
  409059:	40 0f 95 c6          	setne  %sil
  40905d:	48 01 fe             	add    %rdi,%rsi
  409060:	40 f6 c6 0f          	test   $0xf,%sil
  409064:	0f 84 36 03 00 00    	je     4093a0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x480>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  40906a:	48 8d 57 01          	lea    0x1(%rdi),%rdx
  40906e:	48 c1 e7 04          	shl    $0x4,%rdi
  409072:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  409076:	48 01 f8             	add    %rdi,%rax
  409079:	49 89 16             	mov    %rdx,(%r14)
  40907c:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  409080:	48 89 18             	mov    %rbx,(%rax)
        FCS_POS_IDX_TO_CHECK_START_LOOP(src_card)
  409083:	49 83 c7 04          	add    $0x4,%r15
  409087:	4c 39 7c 24 10       	cmp    %r15,0x10(%rsp)
  40908c:	0f 86 22 ff ff ff    	jbe    408fb4 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x94>
            const int_fast32_t ds = pos_idx_to_check[0];
  409092:	4d 0f be 07          	movsbq (%r15),%r8
  409096:	4c 89 c3             	mov    %r8,%rbx
            if (ds == -1)
  409099:	49 83 f8 ff          	cmp    $0xffffffffffffffff,%r8
  40909d:	74 e4                	je     409083 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x163>
            const int dest_cards_num = fcs_col_len(dest_col);
  40909f:	4a 8b 54 c5 00       	mov    0x0(%rbp,%r8,8),%rdx
  4090a4:	4c 89 44 24 08       	mov    %r8,0x8(%rsp)
            const int next_dc = dc + 1;
  4090a9:	45 0f be 6f 01       	movsbl 0x1(%r15),%r13d
            if (!(dest_cards_num <= next_dc + num_vacant_slots))
  4090ae:	0f b6 44 24 26       	movzbl 0x26(%rsp),%eax
            const int dest_cards_num = fcs_col_len(dest_col);
  4090b3:	44 0f be 22          	movsbl (%rdx),%r12d
            if (!(dest_cards_num <= next_dc + num_vacant_slots))
  4090b7:	41 8d 44 05 01       	lea    0x1(%r13,%rax,1),%eax
  4090bc:	44 39 e0             	cmp    %r12d,%eax
  4090bf:	7c c2                	jl     409083 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x163>
            sfs_check_state_begin();
  4090c1:	48 8b 4c 24 30       	mov    0x30(%rsp),%rcx
  4090c6:	48 8d 74 24 60       	lea    0x60(%rsp),%rsi
  4090cb:	48 89 ea             	mov    %rbp,%rdx
  4090ce:	48 8b 7c 24 28       	mov    0x28(%rsp),%rdi
  4090d3:	e8 48 89 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
            my_copy_stack(ds);
  4090d8:	48 8b 54 24 68       	mov    0x68(%rsp),%rdx
  4090dd:	4c 8b 44 24 08       	mov    0x8(%rsp),%r8
  4090e2:	8b 42 14             	mov    0x14(%rdx),%eax
  4090e5:	0f a3 d8             	bt     %ebx,%eax
  4090e8:	0f 83 d2 02 00 00    	jae    4093c0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4a0>
  4090ee:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
            empty_two_cols_from_new_state(soft_thread,
  4090f3:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
                dest_cards_num - dc - 1, 0);
  4090f8:	41 f7 d5             	not    %r13d
            const int cols_indexes[3] = {ds, -1, -1};
  4090fb:	89 5c 24 54          	mov    %ebx,0x54(%rsp)
  4090ff:	4c 63 c3             	movslq %ebx,%r8
                dest_cards_num - dc - 1, 0);
  409102:	43 8d 44 25 00       	lea    0x0(%r13,%r12,1),%eax
            while ((*col_num_cards) == 0)
  409107:	45 31 d2             	xor    %r10d,%r10d
            const int cols_indexes[3] = {ds, -1, -1};
  40910a:	48 c7 44 24 58 ff ff 	movq   $0xffffffffffffffff,0x58(%rsp)
  409111:	ff ff 
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  409113:	89 44 24 70          	mov    %eax,0x70(%rsp)
            empty_two_cols_from_new_state(soft_thread,
  409117:	4c 8b 1f             	mov    (%rdi),%r11
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  40911a:	48 bf 00 00 00 00 ff 	movabs $0xffffffff00000000,%rdi
  409121:	ff ff ff 
  409124:	48 89 7c 24 74       	mov    %rdi,0x74(%rsp)
        int dest_fc_idx = 0;
  409129:	31 ff                	xor    %edi,%edi
            while ((*col_num_cards) == 0)
  40912b:	85 c0                	test   %eax,%eax
  40912d:	0f 85 b3 00 00 00    	jne    4091e6 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x2c6>
  409133:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40913a:	00 00 00 00 
  40913e:	66 90                	xchg   %ax,%ax
  409140:	48 8b 4c 24 60       	mov    0x60(%rsp),%rcx
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  409145:	4a 8b 14 c1          	mov    (%rcx,%r8,8),%rdx
    if (!fc_solve_check_and_add_state(
  409149:	48 8d 74 24 60       	lea    0x60(%rsp),%rsi
    fcs_col_push_card(col, card);
  40914e:	0f b6 5c 24 27       	movzbl 0x27(%rsp),%ebx
  409153:	48 0f be 02          	movsbq (%rdx),%rax
  409157:	8d 48 01             	lea    0x1(%rax),%ecx
  40915a:	88 0a                	mov    %cl,(%rdx)
  40915c:	88 5c 02 01          	mov    %bl,0x1(%rdx,%rax,1)
            fcs_empty_freecell(new_state_key, fc);
  409160:	48 63 44 24 20       	movslq 0x20(%rsp),%rax
  409165:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  40916a:	c6 44 02 40 00       	movb   $0x0,0x40(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  40916f:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  409174:	48 8d 54 24 70       	lea    0x70(%rsp),%rdx
    const_SLOT(hard_thread, soft_thread);
  409179:	48 8b 18             	mov    (%rax),%rbx
    if (!fc_solve_check_and_add_state(
  40917c:	48 89 df             	mov    %rbx,%rdi
  40917f:	e8 ec 89 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  409184:	84 c0                	test   %al,%al
  409186:	0f 84 94 fe ff ff    	je     409020 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x100>
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  40918c:	48 8b 5c 24 60       	mov    0x60(%rsp),%rbx
  409191:	e9 b7 fe ff ff       	jmpq   40904d <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x12d>
  409196:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40919d:	00 00 00 
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4091a0:	89 cf                	mov    %ecx,%edi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  4091a2:	4e 8b 14 c2          	mov    (%rdx,%r8,8),%r10
            ++dest_fc_idx;
  4091a6:	83 c7 01             	add    $0x1,%edi
    fcs_col_pop_card(col, ret);
  4091a9:	45 0f be 0a          	movsbl (%r10),%r9d
  4091ad:	44 89 c9             	mov    %r9d,%ecx
  4091b0:	41 83 e9 01          	sub    $0x1,%r9d
  4091b4:	4d 63 c9             	movslq %r9d,%r9
  4091b7:	83 e9 01             	sub    $0x1,%ecx
  4091ba:	47 0f b6 4c 0a 01    	movzbl 0x1(%r10,%r9,1),%r9d
  4091c0:	41 88 0a             	mov    %cl,(%r10)
  4091c3:	48 0f be c9          	movsbq %cl,%rcx
  4091c7:	41 c6 44 0a 01 00    	movb   $0x0,0x1(%r10,%rcx,1)
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  4091cd:	44 88 4c 32 40       	mov    %r9b,0x40(%rdx,%rsi,1)
            while ((*col_num_cards) == 0)
  4091d2:	83 e8 01             	sub    $0x1,%eax
  4091d5:	0f 84 65 ff ff ff    	je     409140 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x220>
  4091db:	41 ba 01 00 00 00    	mov    $0x1,%r10d
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4091e1:	83 ff 04             	cmp    $0x4,%edi
  4091e4:	74 41                	je     409227 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x307>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4091e6:	48 63 f7             	movslq %edi,%rsi
  4091e9:	80 7c 32 40 00       	cmpb   $0x0,0x40(%rdx,%rsi,1)
  4091ee:	74 b2                	je     4091a2 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x282>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4091f0:	8d 4f 01             	lea    0x1(%rdi),%ecx
  4091f3:	83 f9 04             	cmp    $0x4,%ecx
  4091f6:	74 2a                	je     409222 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x302>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4091f8:	48 63 f1             	movslq %ecx,%rsi
  4091fb:	80 7c 32 40 00       	cmpb   $0x0,0x40(%rdx,%rsi,1)
  409200:	74 9e                	je     4091a0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x280>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  409202:	8d 4f 02             	lea    0x2(%rdi),%ecx
  409205:	83 f9 04             	cmp    $0x4,%ecx
  409208:	74 18                	je     409222 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x302>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  40920a:	48 63 f1             	movslq %ecx,%rsi
  40920d:	80 7c 32 40 00       	cmpb   $0x0,0x40(%rdx,%rsi,1)
  409212:	74 8c                	je     4091a0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x280>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  409214:	85 ff                	test   %edi,%edi
  409216:	75 0a                	jne    409222 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x302>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  409218:	80 7a 43 00          	cmpb   $0x0,0x43(%rdx)
  40921c:	0f 84 6e 02 00 00    	je     409490 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x570>
  409222:	45 84 d2             	test   %r10b,%r10b
  409225:	74 04                	je     40922b <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x30b>
  409227:	89 44 24 70          	mov    %eax,0x70(%rsp)
    while ((*col_num_cards) == 0)
  40922b:	85 c0                	test   %eax,%eax
  40922d:	0f 84 0d ff ff ff    	je     409140 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x220>
  409233:	48 8b 4c 24 60       	mov    0x60(%rsp),%rcx
    char *const indirect_stacks_buffer =
  409238:	4d 8d a3 00 01 00 00 	lea    0x100(%r11),%r12
    int put_cards_in_col_idx = 0;
  40923f:	31 db                	xor    %ebx,%ebx
  409241:	49 c7 c1 ff ff ff ff 	mov    $0xffffffffffffffff,%r9
    char *const indirect_stacks_buffer =
  409248:	4d 89 e5             	mov    %r12,%r13
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40924b:	83 fb 08             	cmp    $0x8,%ebx
  40924e:	0f 84 7c 02 00 00    	je     4094d0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5b0>
        if (fcs_state_col_is_empty(state, ret))
  409254:	48 63 f3             	movslq %ebx,%rsi
  409257:	48 8b 34 f1          	mov    (%rcx,%rsi,8),%rsi
  40925b:	80 3e 00             	cmpb   $0x0,(%rsi)
  40925e:	0f 84 d3 02 00 00    	je     409537 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x617>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  409264:	44 8d 53 01          	lea    0x1(%rbx),%r10d
  409268:	41 83 fa 08          	cmp    $0x8,%r10d
  40926c:	0f 84 5e 02 00 00    	je     4094d0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5b0>
        if (fcs_state_col_is_empty(state, ret))
  409272:	4d 63 da             	movslq %r10d,%r11
  409275:	4a 8b 34 d9          	mov    (%rcx,%r11,8),%rsi
  409279:	80 3e 00             	cmpb   $0x0,(%rsi)
  40927c:	0f 84 ae 01 00 00    	je     409430 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x510>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  409282:	44 8d 53 02          	lea    0x2(%rbx),%r10d
  409286:	41 83 fa 08          	cmp    $0x8,%r10d
  40928a:	0f 84 40 02 00 00    	je     4094d0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5b0>
        if (fcs_state_col_is_empty(state, ret))
  409290:	4d 63 da             	movslq %r10d,%r11
  409293:	4a 8b 34 d9          	mov    (%rcx,%r11,8),%rsi
  409297:	80 3e 00             	cmpb   $0x0,(%rsi)
  40929a:	0f 84 90 01 00 00    	je     409430 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x510>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4092a0:	44 8d 53 03          	lea    0x3(%rbx),%r10d
  4092a4:	41 83 fa 08          	cmp    $0x8,%r10d
  4092a8:	0f 84 22 02 00 00    	je     4094d0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5b0>
        if (fcs_state_col_is_empty(state, ret))
  4092ae:	4d 63 da             	movslq %r10d,%r11
  4092b1:	4a 8b 34 d9          	mov    (%rcx,%r11,8),%rsi
  4092b5:	80 3e 00             	cmpb   $0x0,(%rsi)
  4092b8:	0f 84 72 01 00 00    	je     409430 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x510>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4092be:	44 8d 53 04          	lea    0x4(%rbx),%r10d
  4092c2:	41 83 fa 08          	cmp    $0x8,%r10d
  4092c6:	0f 84 04 02 00 00    	je     4094d0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5b0>
        if (fcs_state_col_is_empty(state, ret))
  4092cc:	4d 63 da             	movslq %r10d,%r11
  4092cf:	4a 8b 34 d9          	mov    (%rcx,%r11,8),%rsi
  4092d3:	80 3e 00             	cmpb   $0x0,(%rsi)
  4092d6:	0f 84 54 01 00 00    	je     409430 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x510>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4092dc:	44 8d 53 05          	lea    0x5(%rbx),%r10d
  4092e0:	41 83 fa 08          	cmp    $0x8,%r10d
  4092e4:	0f 84 e6 01 00 00    	je     4094d0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5b0>
        if (fcs_state_col_is_empty(state, ret))
  4092ea:	4d 63 da             	movslq %r10d,%r11
  4092ed:	4a 8b 34 d9          	mov    (%rcx,%r11,8),%rsi
  4092f1:	80 3e 00             	cmpb   $0x0,(%rsi)
  4092f4:	0f 84 36 01 00 00    	je     409430 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x510>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4092fa:	44 8d 53 06          	lea    0x6(%rbx),%r10d
  4092fe:	41 83 fa 08          	cmp    $0x8,%r10d
  409302:	0f 84 c8 01 00 00    	je     4094d0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5b0>
        if (fcs_state_col_is_empty(state, ret))
  409308:	4d 63 da             	movslq %r10d,%r11
  40930b:	4a 8b 34 d9          	mov    (%rcx,%r11,8),%rsi
  40930f:	80 3e 00             	cmpb   $0x0,(%rsi)
  409312:	0f 84 18 01 00 00    	je     409430 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x510>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  409318:	85 db                	test   %ebx,%ebx
  40931a:	0f 85 b0 01 00 00    	jne    4094d0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5b0>
        if (fcs_state_col_is_empty(state, ret))
  409320:	48 8b 49 38          	mov    0x38(%rcx),%rcx
    return -1;
  409324:	41 ba ff ff ff ff    	mov    $0xffffffff,%r10d
  40932a:	4d 89 cb             	mov    %r9,%r11
        if (fcs_state_col_is_empty(state, ret))
  40932d:	80 39 00             	cmpb   $0x0,(%rcx)
  409330:	0f 84 ed 00 00 00    	je     409423 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x503>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  409336:	48 8b 74 24 68       	mov    0x68(%rsp),%rsi
  40933b:	8b 4e 14             	mov    0x14(%rsi),%ecx
  40933e:	44 0f a3 d1          	bt     %r10d,%ecx
  409342:	0f 83 fe 00 00 00    	jae    409446 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x526>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  409348:	4a 8b 3c c2          	mov    (%rdx,%r8,8),%rdi
    fcs_col_pop_card(col, ret);
  40934c:	0f be 37             	movsbl (%rdi),%esi
  40934f:	89 f1                	mov    %esi,%ecx
  409351:	83 ee 01             	sub    $0x1,%esi
  409354:	83 e9 01             	sub    $0x1,%ecx
  409357:	48 63 f6             	movslq %esi,%rsi
        --(*col_num_cards);
  40935a:	83 e8 01             	sub    $0x1,%eax
  40935d:	0f b6 74 37 01       	movzbl 0x1(%rdi,%rsi,1),%esi
  409362:	88 0f                	mov    %cl,(%rdi)
  409364:	48 0f be c9          	movsbq %cl,%rcx
  409368:	c6 44 0f 01 00       	movb   $0x0,0x1(%rdi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  40936d:	4a 8b 3c da          	mov    (%rdx,%r11,8),%rdi
    fcs_col_push_card(col, card);
  409371:	48 0f be 0f          	movsbq (%rdi),%rcx
  409375:	44 8d 51 01          	lea    0x1(%rcx),%r10d
  409379:	44 88 17             	mov    %r10b,(%rdi)
  40937c:	40 88 74 0f 01       	mov    %sil,0x1(%rdi,%rcx,1)
  409381:	48 8b 4c 24 60       	mov    0x60(%rsp),%rcx
  409386:	89 44 24 70          	mov    %eax,0x70(%rsp)
        while ((*col_num_cards) == 0)
  40938a:	0f 84 b5 fd ff ff    	je     409145 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x225>
  409390:	e9 b6 fe ff ff       	jmpq   40924b <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x32b>
  409395:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40939c:	00 00 00 00 
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  4093a0:	48 83 c6 10          	add    $0x10,%rsi
  4093a4:	48 89 c7             	mov    %rax,%rdi
  4093a7:	48 c1 e6 04          	shl    $0x4,%rsi
  4093ab:	e8 c0 7d ff ff       	callq  401170 <realloc@plt>
  4093b0:	49 8b 3e             	mov    (%r14),%rdi
        list->states =
  4093b3:	49 89 46 08          	mov    %rax,0x8(%r14)
  4093b7:	e9 ae fc ff ff       	jmpq   40906a <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x14a>
  4093bc:	0f 1f 40 00          	nopl   0x0(%rax)
            my_copy_stack(ds);
  4093c0:	0f ab d8             	bts    %ebx,%eax
  4093c3:	89 42 14             	mov    %eax,0x14(%rdx)
  4093c6:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  4093cb:	4c 89 c0             	mov    %r8,%rax
  4093ce:	48 c1 e0 07          	shl    $0x7,%rax
  4093d2:	48 03 44 24 40       	add    0x40(%rsp),%rax
  4093d7:	4a 8b 34 c2          	mov    (%rdx,%r8,8),%rsi
  4093db:	0f be 0e             	movsbl (%rsi),%ecx
  4093de:	83 c1 01             	add    $0x1,%ecx
  4093e1:	48 63 c9             	movslq %ecx,%rcx
  4093e4:	48 83 f9 08          	cmp    $0x8,%rcx
  4093e8:	0f 83 b2 00 00 00    	jae    4094a0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x580>
  4093ee:	f6 c1 04             	test   $0x4,%cl
  4093f1:	0f 85 4e 01 00 00    	jne    409545 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x625>
  4093f7:	48 85 c9             	test   %rcx,%rcx
  4093fa:	0f 85 10 01 00 00    	jne    409510 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5f0>
  409400:	4a 89 04 c2          	mov    %rax,(%rdx,%r8,8)
  409404:	e9 ea fc ff ff       	jmpq   4090f3 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x1d3>
  409409:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  409410:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
  409417:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
  40941e:	e9 25 fc ff ff       	jmpq   409048 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x128>
        if (fcs_state_col_is_empty(state, ret))
  409423:	41 ba 07 00 00 00    	mov    $0x7,%r10d
  409429:	41 bb 07 00 00 00    	mov    $0x7,%r11d
  40942f:	90                   	nop
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  409430:	48 8b 74 24 68       	mov    0x68(%rsp),%rsi
  409435:	41 8d 5a 01          	lea    0x1(%r10),%ebx
  409439:	8b 4e 14             	mov    0x14(%rsi),%ecx
  40943c:	44 0f a3 d1          	bt     %r10d,%ecx
  409440:	0f 82 02 ff ff ff    	jb     409348 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x428>
  409446:	4e 8d 24 da          	lea    (%rdx,%r11,8),%r12
  40944a:	44 0f ab d1          	bts    %r10d,%ecx
  40944e:	41 c1 e2 07          	shl    $0x7,%r10d
  409452:	89 4e 14             	mov    %ecx,0x14(%rsi)
  409455:	49 8b 34 24          	mov    (%r12),%rsi
  409459:	4d 63 d2             	movslq %r10d,%r10
  40945c:	4d 01 ea             	add    %r13,%r10
  40945f:	0f be 0e             	movsbl (%rsi),%ecx
  409462:	83 c1 01             	add    $0x1,%ecx
  409465:	48 63 c9             	movslq %ecx,%rcx
  409468:	48 83 f9 08          	cmp    $0x8,%rcx
  40946c:	72 72                	jb     4094e0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5c0>
  40946e:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  409473:	49 89 7c 0a f8       	mov    %rdi,-0x8(%r10,%rcx,1)
  409478:	48 83 e9 01          	sub    $0x1,%rcx
  40947c:	4c 89 d7             	mov    %r10,%rdi
  40947f:	48 c1 e9 03          	shr    $0x3,%rcx
  409483:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  409486:	4d 89 14 24          	mov    %r10,(%r12)
  40948a:	e9 b9 fe ff ff       	jmpq   409348 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x428>
  40948f:	90                   	nop
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  409490:	bf 03 00 00 00       	mov    $0x3,%edi
  409495:	be 03 00 00 00       	mov    $0x3,%esi
  40949a:	e9 03 fd ff ff       	jmpq   4091a2 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x282>
  40949f:	90                   	nop
            my_copy_stack(ds);
  4094a0:	48 8b 54 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdx
  4094a5:	48 89 c7             	mov    %rax,%rdi
  4094a8:	48 89 54 08 f8       	mov    %rdx,-0x8(%rax,%rcx,1)
  4094ad:	48 83 e9 01          	sub    $0x1,%rcx
  4094b1:	48 c1 e9 03          	shr    $0x3,%rcx
  4094b5:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4094b8:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  4094bd:	4a 89 04 c2          	mov    %rax,(%rdx,%r8,8)
  4094c1:	e9 2d fc ff ff       	jmpq   4090f3 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x1d3>
  4094c6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  4094cd:	00 00 00 
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4094d0:	31 db                	xor    %ebx,%ebx
    return -1;
  4094d2:	41 ba ff ff ff ff    	mov    $0xffffffff,%r10d
  4094d8:	4d 89 cb             	mov    %r9,%r11
  4094db:	e9 56 fe ff ff       	jmpq   409336 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x416>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4094e0:	f6 c1 04             	test   $0x4,%cl
  4094e3:	75 76                	jne    40955b <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x63b>
  4094e5:	48 85 c9             	test   %rcx,%rcx
  4094e8:	74 9c                	je     409486 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x566>
  4094ea:	0f b6 3e             	movzbl (%rsi),%edi
  4094ed:	41 88 3a             	mov    %dil,(%r10)
  4094f0:	f6 c1 02             	test   $0x2,%cl
  4094f3:	74 91                	je     409486 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x566>
  4094f5:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  4094fa:	66 41 89 74 0a fe    	mov    %si,-0x2(%r10,%rcx,1)
  409500:	eb 84                	jmp    409486 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x566>
  409502:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409509:	00 00 00 00 
  40950d:	0f 1f 00             	nopl   (%rax)
            my_copy_stack(ds);
  409510:	0f b6 16             	movzbl (%rsi),%edx
  409513:	88 10                	mov    %dl,(%rax)
  409515:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  40951a:	f6 c1 02             	test   $0x2,%cl
  40951d:	0f 84 dd fe ff ff    	je     409400 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4e0>
  409523:	0f b7 54 0e fe       	movzwl -0x2(%rsi,%rcx,1),%edx
  409528:	66 89 54 08 fe       	mov    %dx,-0x2(%rax,%rcx,1)
  40952d:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  409532:	e9 c9 fe ff ff       	jmpq   409400 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4e0>
        if (fcs_state_col_is_empty(state, ret))
  409537:	4c 63 db             	movslq %ebx,%r11
  40953a:	83 c3 01             	add    $0x1,%ebx
  40953d:	4d 89 da             	mov    %r11,%r10
  409540:	e9 f1 fd ff ff       	jmpq   409336 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x416>
            my_copy_stack(ds);
  409545:	8b 16                	mov    (%rsi),%edx
  409547:	89 10                	mov    %edx,(%rax)
  409549:	8b 54 0e fc          	mov    -0x4(%rsi,%rcx,1),%edx
  40954d:	89 54 08 fc          	mov    %edx,-0x4(%rax,%rcx,1)
  409551:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  409556:	e9 a5 fe ff ff       	jmpq   409400 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4e0>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  40955b:	8b 3e                	mov    (%rsi),%edi
  40955d:	41 89 3a             	mov    %edi,(%r10)
  409560:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  409564:	41 89 74 0a fc       	mov    %esi,-0x4(%r10,%rcx,1)
  409569:	e9 18 ff ff ff       	jmpq   409486 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x566>
  40956e:	66 90                	xchg   %ax,%ax

0000000000409570 <fc_solve_sfs_move_freecell_cards_to_founds>:
{
  409570:	41 55                	push   %r13
  409572:	41 54                	push   %r12
  409574:	55                   	push   %rbp
  409575:	53                   	push   %rbx
  409576:	48 83 ec 28          	sub    $0x28,%rsp
        const fcs_card card = fcs_freecell_card(state, fc);
  40957a:	0f b6 5e 43          	movzbl 0x43(%rsi),%ebx
        if (fcs_card_is_empty(card))
  40957e:	84 db                	test   %bl,%bl
  409580:	75 3e                	jne    4095c0 <fc_solve_sfs_move_freecell_cards_to_founds+0x50>
        const fcs_card card = fcs_freecell_card(state, fc);
  409582:	0f b6 46 42          	movzbl 0x42(%rsi),%eax
        if (fcs_card_is_empty(card))
  409586:	84 c0                	test   %al,%al
  409588:	0f 85 02 01 00 00    	jne    409690 <fc_solve_sfs_move_freecell_cards_to_founds+0x120>
        const fcs_card card = fcs_freecell_card(state, fc);
  40958e:	0f b6 46 41          	movzbl 0x41(%rsi),%eax
        if (fcs_card_is_empty(card))
  409592:	84 c0                	test   %al,%al
  409594:	0f 85 26 01 00 00    	jne    4096c0 <fc_solve_sfs_move_freecell_cards_to_founds+0x150>
        const fcs_card card = fcs_freecell_card(state, fc);
  40959a:	0f b6 46 40          	movzbl 0x40(%rsi),%eax
        if (fcs_card_is_empty(card))
  40959e:	84 c0                	test   %al,%al
  4095a0:	0f 85 4a 01 00 00    	jne    4096f0 <fc_solve_sfs_move_freecell_cards_to_founds+0x180>
}
  4095a6:	48 83 c4 28          	add    $0x28,%rsp
  4095aa:	5b                   	pop    %rbx
  4095ab:	5d                   	pop    %rbp
  4095ac:	41 5c                	pop    %r12
  4095ae:	41 5d                	pop    %r13
  4095b0:	c3                   	retq   
  4095b1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4095b8:	00 00 00 00 
  4095bc:	0f 1f 40 00          	nopl   0x0(%rax)
                fcs_card_rank(card) - 1)
  4095c0:	89 d8                	mov    %ebx,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4095c2:	83 e3 03             	and    $0x3,%ebx
  4095c5:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  4095cb:	c0 f8 02             	sar    $0x2,%al
  4095ce:	0f be c0             	movsbl %al,%eax
  4095d1:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4095d4:	44 39 c0             	cmp    %r8d,%eax
  4095d7:	75 a9                	jne    409582 <fc_solve_sfs_move_freecell_cards_to_founds+0x12>
    for (int fc = LOCAL_FREECELLS_NUM - 1; fc >= 0; --fc)
  4095d9:	bd 03 00 00 00       	mov    $0x3,%ebp
  4095de:	49 89 fc             	mov    %rdi,%r12
            sfs_check_state_begin();
  4095e1:	48 8b 3f             	mov    (%rdi),%rdi
  4095e4:	49 89 cd             	mov    %rcx,%r13
  4095e7:	48 89 d1             	mov    %rdx,%rcx
  4095ea:	48 89 f2             	mov    %rsi,%rdx
  4095ed:	48 89 e6             	mov    %rsp,%rsi
  4095f0:	e8 2b 84 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
            fcs_empty_freecell(new_state_key, fc);
  4095f5:	48 8b 04 24          	mov    (%rsp),%rax
    if (!fc_solve_check_and_add_state(
  4095f9:	48 8d 54 24 10       	lea    0x10(%rsp),%rdx
  4095fe:	48 89 e6             	mov    %rsp,%rsi
  409601:	c6 44 28 40 00       	movb   $0x0,0x40(%rax,%rbp,1)
            fcs_increment_foundation(
  409606:	80 44 18 44 01       	addb   $0x1,0x44(%rax,%rbx,1)
    const_SLOT(hard_thread, soft_thread);
  40960b:	49 8b 1c 24          	mov    (%r12),%rbx
    if (!fc_solve_check_and_add_state(
  40960f:	48 89 df             	mov    %rbx,%rdi
  409612:	e8 59 85 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  409617:	84 c0                	test   %al,%al
  409619:	0f 85 01 01 00 00    	jne    409720 <fc_solve_sfs_move_freecell_cards_to_founds+0x1b0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  40961f:	80 bb 18 05 00 00 00 	cmpb   $0x0,0x518(%rbx)
  409626:	0f 84 24 01 00 00    	je     409750 <fc_solve_sfs_move_freecell_cards_to_founds+0x1e0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  40962c:	48 8b 93 b0 00 00 00 	mov    0xb0(%rbx),%rdx
  409633:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  409638:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  40963b:	48 8b 04 24          	mov    (%rsp),%rax
  40963f:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  409646:	48 8b 5c 24 10       	mov    0x10(%rsp),%rbx
    if ((!((list->num_states + (list->states != NULL)) &
  40964b:	49 8b 45 08          	mov    0x8(%r13),%rax
  40964f:	31 d2                	xor    %edx,%edx
  409651:	49 8b 7d 00          	mov    0x0(%r13),%rdi
  409655:	48 85 c0             	test   %rax,%rax
  409658:	0f 95 c2             	setne  %dl
  40965b:	48 01 fa             	add    %rdi,%rdx
  40965e:	f6 c2 0f             	test   $0xf,%dl
  409661:	0f 84 c9 00 00 00    	je     409730 <fc_solve_sfs_move_freecell_cards_to_founds+0x1c0>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  409667:	48 8d 57 01          	lea    0x1(%rdi),%rdx
  40966b:	48 c1 e7 04          	shl    $0x4,%rdi
  40966f:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  409673:	48 01 f8             	add    %rdi,%rax
  409676:	49 89 55 00          	mov    %rdx,0x0(%r13)
  40967a:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  40967e:	48 89 18             	mov    %rbx,(%rax)
}
  409681:	48 83 c4 28          	add    $0x28,%rsp
  409685:	5b                   	pop    %rbx
  409686:	5d                   	pop    %rbp
  409687:	41 5c                	pop    %r12
  409689:	41 5d                	pop    %r13
  40968b:	c3                   	retq   
  40968c:	0f 1f 40 00          	nopl   0x0(%rax)
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409690:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409693:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409696:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  409699:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40969c:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  4096a2:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4096a5:	41 39 c0             	cmp    %eax,%r8d
  4096a8:	0f 85 e0 fe ff ff    	jne    40958e <fc_solve_sfs_move_freecell_cards_to_founds+0x1e>
    for (int fc = LOCAL_FREECELLS_NUM - 1; fc >= 0; --fc)
  4096ae:	bd 02 00 00 00       	mov    $0x2,%ebp
  4096b3:	e9 26 ff ff ff       	jmpq   4095de <fc_solve_sfs_move_freecell_cards_to_founds+0x6e>
  4096b8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4096bf:	00 
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4096c0:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  4096c3:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4096c6:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  4096c9:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4096cc:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  4096d2:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4096d5:	41 39 c0             	cmp    %eax,%r8d
  4096d8:	0f 85 bc fe ff ff    	jne    40959a <fc_solve_sfs_move_freecell_cards_to_founds+0x2a>
    for (int fc = LOCAL_FREECELLS_NUM - 1; fc >= 0; --fc)
  4096de:	bd 01 00 00 00       	mov    $0x1,%ebp
  4096e3:	e9 f6 fe ff ff       	jmpq   4095de <fc_solve_sfs_move_freecell_cards_to_founds+0x6e>
  4096e8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4096ef:	00 
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4096f0:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  4096f3:	c0 f8 02             	sar    $0x2,%al
    for (int fc = LOCAL_FREECELLS_NUM - 1; fc >= 0; --fc)
  4096f6:	31 ed                	xor    %ebp,%ebp
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4096f8:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  4096fb:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4096fe:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409704:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409707:	41 39 c0             	cmp    %eax,%r8d
  40970a:	0f 84 ce fe ff ff    	je     4095de <fc_solve_sfs_move_freecell_cards_to_founds+0x6e>
}
  409710:	48 83 c4 28          	add    $0x28,%rsp
  409714:	5b                   	pop    %rbx
  409715:	5d                   	pop    %rbp
  409716:	41 5c                	pop    %r12
  409718:	41 5d                	pop    %r13
  40971a:	c3                   	retq   
  40971b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  409720:	48 8b 1c 24          	mov    (%rsp),%rbx
  409724:	e9 22 ff ff ff       	jmpq   40964b <fc_solve_sfs_move_freecell_cards_to_founds+0xdb>
  409729:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  409730:	48 8d 72 10          	lea    0x10(%rdx),%rsi
  409734:	48 89 c7             	mov    %rax,%rdi
  409737:	48 c1 e6 04          	shl    $0x4,%rsi
  40973b:	e8 30 7a ff ff       	callq  401170 <realloc@plt>
  409740:	49 8b 7d 00          	mov    0x0(%r13),%rdi
        list->states =
  409744:	49 89 45 08          	mov    %rax,0x8(%r13)
  409748:	e9 1a ff ff ff       	jmpq   409667 <fc_solve_sfs_move_freecell_cards_to_founds+0xf7>
  40974d:	0f 1f 00             	nopl   (%rax)
  409750:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
  409757:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
  40975e:	e9 e3 fe ff ff       	jmpq   409646 <fc_solve_sfs_move_freecell_cards_to_founds+0xd6>
  409763:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40976a:	00 00 00 00 
  40976e:	66 90                	xchg   %ax,%ax

0000000000409770 <fc_solve_sfs_move_top_stack_cards_to_founds>:
{
  409770:	41 56                	push   %r14
  409772:	41 55                	push   %r13
  409774:	41 54                	push   %r12
  409776:	55                   	push   %rbp
  409777:	53                   	push   %rbx
  409778:	48 83 ec 20          	sub    $0x20,%rsp
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  40977c:	4c 8b 06             	mov    (%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  40977f:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  409783:	48 85 c0             	test   %rax,%rax
  409786:	0f 85 e4 00 00 00    	jne    409870 <fc_solve_sfs_move_top_stack_cards_to_founds+0x100>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  40978c:	4c 8b 46 08          	mov    0x8(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  409790:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  409794:	48 85 c0             	test   %rax,%rax
  409797:	0f 85 03 01 00 00    	jne    4098a0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x130>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  40979d:	4c 8b 46 10          	mov    0x10(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  4097a1:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  4097a5:	48 85 c0             	test   %rax,%rax
  4097a8:	0f 85 22 01 00 00    	jne    4098d0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x160>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  4097ae:	4c 8b 46 18          	mov    0x18(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  4097b2:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  4097b6:	48 85 c0             	test   %rax,%rax
  4097b9:	0f 85 41 01 00 00    	jne    409900 <fc_solve_sfs_move_top_stack_cards_to_founds+0x190>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  4097bf:	4c 8b 46 20          	mov    0x20(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  4097c3:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  4097c7:	48 85 c0             	test   %rax,%rax
  4097ca:	75 44                	jne    409810 <fc_solve_sfs_move_top_stack_cards_to_founds+0xa0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  4097cc:	4c 8b 46 28          	mov    0x28(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  4097d0:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  4097d4:	48 85 c0             	test   %rax,%rax
  4097d7:	75 67                	jne    409840 <fc_solve_sfs_move_top_stack_cards_to_founds+0xd0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  4097d9:	4c 8b 46 30          	mov    0x30(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  4097dd:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  4097e1:	48 85 c0             	test   %rax,%rax
  4097e4:	0f 85 46 01 00 00    	jne    409930 <fc_solve_sfs_move_top_stack_cards_to_founds+0x1c0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  4097ea:	4c 8b 46 38          	mov    0x38(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  4097ee:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  4097f2:	48 85 c0             	test   %rax,%rax
  4097f5:	0f 85 45 02 00 00    	jne    409a40 <fc_solve_sfs_move_top_stack_cards_to_founds+0x2d0>
}
  4097fb:	48 83 c4 20          	add    $0x20,%rsp
  4097ff:	5b                   	pop    %rbx
  409800:	5d                   	pop    %rbp
  409801:	41 5c                	pop    %r12
  409803:	41 5d                	pop    %r13
  409805:	41 5e                	pop    %r14
  409807:	c3                   	retq   
  409808:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40980f:	00 
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409810:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409815:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409818:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40981b:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  40981e:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409821:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409827:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40982a:	41 39 c0             	cmp    %eax,%r8d
  40982d:	75 9d                	jne    4097cc <fc_solve_sfs_move_top_stack_cards_to_founds+0x5c>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  40982f:	41 bc 04 00 00 00    	mov    $0x4,%r12d
  409835:	e9 26 01 00 00       	jmpq   409960 <fc_solve_sfs_move_top_stack_cards_to_founds+0x1f0>
  40983a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409840:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409845:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409848:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40984b:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  40984e:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409851:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409857:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40985a:	41 39 c0             	cmp    %eax,%r8d
  40985d:	0f 85 76 ff ff ff    	jne    4097d9 <fc_solve_sfs_move_top_stack_cards_to_founds+0x69>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409863:	41 bc 05 00 00 00    	mov    $0x5,%r12d
  409869:	e9 f2 00 00 00       	jmpq   409960 <fc_solve_sfs_move_top_stack_cards_to_founds+0x1f0>
  40986e:	66 90                	xchg   %ax,%ax
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409870:	41 0f b6 1c 00       	movzbl (%r8,%rax,1),%ebx
                fcs_card_rank(card) - 1)
  409875:	89 d8                	mov    %ebx,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409877:	83 e3 03             	and    $0x3,%ebx
  40987a:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409880:	c0 f8 02             	sar    $0x2,%al
  409883:	0f be c0             	movsbl %al,%eax
  409886:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409889:	44 39 c0             	cmp    %r8d,%eax
  40988c:	0f 85 fa fe ff ff    	jne    40978c <fc_solve_sfs_move_top_stack_cards_to_founds+0x1c>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409892:	45 31 e4             	xor    %r12d,%r12d
  409895:	e9 c6 00 00 00       	jmpq   409960 <fc_solve_sfs_move_top_stack_cards_to_founds+0x1f0>
  40989a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  4098a0:	41 0f b6 1c 00       	movzbl (%r8,%rax,1),%ebx
                fcs_card_rank(card) - 1)
  4098a5:	89 d8                	mov    %ebx,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4098a7:	83 e3 03             	and    $0x3,%ebx
  4098aa:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  4098b0:	c0 f8 02             	sar    $0x2,%al
  4098b3:	0f be c0             	movsbl %al,%eax
  4098b6:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4098b9:	44 39 c0             	cmp    %r8d,%eax
  4098bc:	0f 85 db fe ff ff    	jne    40979d <fc_solve_sfs_move_top_stack_cards_to_founds+0x2d>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  4098c2:	41 bc 01 00 00 00    	mov    $0x1,%r12d
  4098c8:	e9 93 00 00 00       	jmpq   409960 <fc_solve_sfs_move_top_stack_cards_to_founds+0x1f0>
  4098cd:	0f 1f 00             	nopl   (%rax)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  4098d0:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4098d5:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  4098d8:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4098db:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  4098de:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4098e1:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  4098e7:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4098ea:	41 39 c0             	cmp    %eax,%r8d
  4098ed:	0f 85 bb fe ff ff    	jne    4097ae <fc_solve_sfs_move_top_stack_cards_to_founds+0x3e>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  4098f3:	41 bc 02 00 00 00    	mov    $0x2,%r12d
  4098f9:	eb 65                	jmp    409960 <fc_solve_sfs_move_top_stack_cards_to_founds+0x1f0>
  4098fb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409900:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409905:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409908:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40990b:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  40990e:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409911:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409917:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40991a:	41 39 c0             	cmp    %eax,%r8d
  40991d:	0f 85 9c fe ff ff    	jne    4097bf <fc_solve_sfs_move_top_stack_cards_to_founds+0x4f>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409923:	41 bc 03 00 00 00    	mov    $0x3,%r12d
  409929:	eb 35                	jmp    409960 <fc_solve_sfs_move_top_stack_cards_to_founds+0x1f0>
  40992b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409930:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409935:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409938:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40993b:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  40993e:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409941:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409947:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40994a:	41 39 c0             	cmp    %eax,%r8d
  40994d:	0f 85 97 fe ff ff    	jne    4097ea <fc_solve_sfs_move_top_stack_cards_to_founds+0x7a>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409953:	41 bc 06 00 00 00    	mov    $0x6,%r12d
  409959:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    tests_define_accessors();
  409960:	4c 8b 37             	mov    (%rdi),%r14
            sfs_check_state_begin();
  409963:	48 89 cd             	mov    %rcx,%rbp
  409966:	49 89 fd             	mov    %rdi,%r13
  409969:	48 89 d1             	mov    %rdx,%rcx
  40996c:	48 89 f2             	mov    %rsi,%rdx
  40996f:	48 89 e6             	mov    %rsp,%rsi
  409972:	4c 89 f7             	mov    %r14,%rdi
  409975:	e8 a6 80 ff ff       	callq  401a20 <fc_solve_sfs_check_state_begin>
            my_copy_stack(stack_idx);
  40997a:	48 8b 54 24 08       	mov    0x8(%rsp),%rdx
  40997f:	8b 42 14             	mov    0x14(%rdx),%eax
  409982:	44 0f a3 e0          	bt     %r12d,%eax
  409986:	0f 83 f4 00 00 00    	jae    409a80 <fc_solve_sfs_move_top_stack_cards_to_founds+0x310>
  40998c:	48 8b 04 24          	mov    (%rsp),%rax
  409990:	4a 8b 14 e0          	mov    (%rax,%r12,8),%rdx
    fcs_col_pop_top(col);
  409994:	0f b6 02             	movzbl (%rdx),%eax
    if (!fc_solve_check_and_add_state(
  409997:	48 89 e6             	mov    %rsp,%rsi
  40999a:	83 e8 01             	sub    $0x1,%eax
  40999d:	88 02                	mov    %al,(%rdx)
  40999f:	48 0f be c0          	movsbq %al,%rax
  4099a3:	c6 44 02 01 00       	movb   $0x0,0x1(%rdx,%rax,1)
            fcs_increment_foundation(
  4099a8:	48 8b 04 24          	mov    (%rsp),%rax
  4099ac:	48 8d 54 24 10       	lea    0x10(%rsp),%rdx
  4099b1:	80 44 18 44 01       	addb   $0x1,0x44(%rax,%rbx,1)
    const_SLOT(hard_thread, soft_thread);
  4099b6:	49 8b 5d 00          	mov    0x0(%r13),%rbx
    if (!fc_solve_check_and_add_state(
  4099ba:	48 89 df             	mov    %rbx,%rdi
  4099bd:	e8 ae 81 ff ff       	callq  401b70 <fc_solve_check_and_add_state>
  4099c2:	84 c0                	test   %al,%al
  4099c4:	0f 85 26 01 00 00    	jne    409af0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x380>
        if (HT_FIELD(hard_thread, allocated_from_list))
  4099ca:	80 bb 18 05 00 00 00 	cmpb   $0x0,0x518(%rbx)
  4099d1:	0f 84 49 01 00 00    	je     409b20 <fc_solve_sfs_move_top_stack_cards_to_founds+0x3b0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  4099d7:	48 8b 93 b0 00 00 00 	mov    0xb0(%rbx),%rdx
  4099de:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  4099e3:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  4099e6:	48 8b 04 24          	mov    (%rsp),%rax
  4099ea:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
        return FCS_STATE_kv_to_collectible(&existing_state);
  4099f1:	48 8b 5c 24 10       	mov    0x10(%rsp),%rbx
    if ((!((list->num_states + (list->states != NULL)) &
  4099f6:	48 8b 45 08          	mov    0x8(%rbp),%rax
  4099fa:	31 d2                	xor    %edx,%edx
  4099fc:	48 8b 7d 00          	mov    0x0(%rbp),%rdi
  409a00:	48 85 c0             	test   %rax,%rax
  409a03:	0f 95 c2             	setne  %dl
  409a06:	48 01 fa             	add    %rdi,%rdx
  409a09:	f6 c2 0f             	test   $0xf,%dl
  409a0c:	0f 84 ee 00 00 00    	je     409b00 <fc_solve_sfs_move_top_stack_cards_to_founds+0x390>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  409a12:	48 8d 57 01          	lea    0x1(%rdi),%rdx
  409a16:	48 c1 e7 04          	shl    $0x4,%rdi
  409a1a:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  409a1e:	48 01 f8             	add    %rdi,%rax
  409a21:	48 89 55 00          	mov    %rdx,0x0(%rbp)
  409a25:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  409a29:	48 89 18             	mov    %rbx,(%rax)
}
  409a2c:	48 83 c4 20          	add    $0x20,%rsp
  409a30:	5b                   	pop    %rbx
  409a31:	5d                   	pop    %rbp
  409a32:	41 5c                	pop    %r12
  409a34:	41 5d                	pop    %r13
  409a36:	41 5e                	pop    %r14
  409a38:	c3                   	retq   
  409a39:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409a40:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409a45:	41 bc 07 00 00 00    	mov    $0x7,%r12d
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409a4b:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409a4e:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409a51:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  409a54:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409a57:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409a5d:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409a60:	41 39 c0             	cmp    %eax,%r8d
  409a63:	0f 84 f7 fe ff ff    	je     409960 <fc_solve_sfs_move_top_stack_cards_to_founds+0x1f0>
}
  409a69:	48 83 c4 20          	add    $0x20,%rsp
  409a6d:	5b                   	pop    %rbx
  409a6e:	5d                   	pop    %rbp
  409a6f:	41 5c                	pop    %r12
  409a71:	41 5d                	pop    %r13
  409a73:	41 5e                	pop    %r14
  409a75:	c3                   	retq   
  409a76:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  409a7d:	00 00 00 
            my_copy_stack(stack_idx);
  409a80:	48 8b 0c 24          	mov    (%rsp),%rcx
  409a84:	4d 63 c4             	movslq %r12d,%r8
  409a87:	44 0f ab e0          	bts    %r12d,%eax
  409a8b:	41 c1 e4 07          	shl    $0x7,%r12d
  409a8f:	89 42 14             	mov    %eax,0x14(%rdx)
  409a92:	4d 63 e4             	movslq %r12d,%r12
  409a95:	4b 8d 94 26 00 01 00 	lea    0x100(%r14,%r12,1),%rdx
  409a9c:	00 
  409a9d:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  409aa1:	0f be 06             	movsbl (%rsi),%eax
  409aa4:	83 c0 01             	add    $0x1,%eax
  409aa7:	48 98                	cltq   
  409aa9:	48 83 f8 08          	cmp    $0x8,%rax
  409aad:	0f 83 8d 00 00 00    	jae    409b40 <fc_solve_sfs_move_top_stack_cards_to_founds+0x3d0>
  409ab3:	a8 04                	test   $0x4,%al
  409ab5:	0f 85 a3 00 00 00    	jne    409b5e <fc_solve_sfs_move_top_stack_cards_to_founds+0x3ee>
  409abb:	48 85 c0             	test   %rax,%rax
  409abe:	74 20                	je     409ae0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x370>
  409ac0:	0f b6 0e             	movzbl (%rsi),%ecx
  409ac3:	88 0a                	mov    %cl,(%rdx)
  409ac5:	48 8b 0c 24          	mov    (%rsp),%rcx
  409ac9:	a8 02                	test   $0x2,%al
  409acb:	74 13                	je     409ae0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x370>
  409acd:	0f b7 4c 06 fe       	movzwl -0x2(%rsi,%rax,1),%ecx
  409ad2:	66 89 4c 02 fe       	mov    %cx,-0x2(%rdx,%rax,1)
  409ad7:	48 8b 0c 24          	mov    (%rsp),%rcx
  409adb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  409ae0:	4a 89 14 c1          	mov    %rdx,(%rcx,%r8,8)
  409ae4:	e9 ab fe ff ff       	jmpq   409994 <fc_solve_sfs_move_top_stack_cards_to_founds+0x224>
  409ae9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  409af0:	48 8b 1c 24          	mov    (%rsp),%rbx
  409af4:	e9 fd fe ff ff       	jmpq   4099f6 <fc_solve_sfs_move_top_stack_cards_to_founds+0x286>
  409af9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  409b00:	48 8d 72 10          	lea    0x10(%rdx),%rsi
  409b04:	48 89 c7             	mov    %rax,%rdi
  409b07:	48 c1 e6 04          	shl    $0x4,%rsi
  409b0b:	e8 60 76 ff ff       	callq  401170 <realloc@plt>
  409b10:	48 8b 7d 00          	mov    0x0(%rbp),%rdi
        list->states =
  409b14:	48 89 45 08          	mov    %rax,0x8(%rbp)
  409b18:	e9 f5 fe ff ff       	jmpq   409a12 <fc_solve_sfs_move_top_stack_cards_to_founds+0x2a2>
  409b1d:	0f 1f 00             	nopl   (%rax)
  409b20:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
  409b27:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
  409b2e:	e9 be fe ff ff       	jmpq   4099f1 <fc_solve_sfs_move_top_stack_cards_to_founds+0x281>
  409b33:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409b3a:	00 00 00 00 
  409b3e:	66 90                	xchg   %ax,%ax
  409b40:	48 8b 4c 06 f8       	mov    -0x8(%rsi,%rax,1),%rcx
  409b45:	48 89 d7             	mov    %rdx,%rdi
  409b48:	48 89 4c 02 f8       	mov    %rcx,-0x8(%rdx,%rax,1)
  409b4d:	48 8d 48 ff          	lea    -0x1(%rax),%rcx
  409b51:	48 c1 e9 03          	shr    $0x3,%rcx
  409b55:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  409b58:	48 8b 0c 24          	mov    (%rsp),%rcx
  409b5c:	eb 82                	jmp    409ae0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x370>
  409b5e:	8b 0e                	mov    (%rsi),%ecx
  409b60:	89 0a                	mov    %ecx,(%rdx)
  409b62:	8b 4c 06 fc          	mov    -0x4(%rsi,%rax,1),%ecx
  409b66:	89 4c 02 fc          	mov    %ecx,-0x4(%rdx,%rax,1)
  409b6a:	48 8b 0c 24          	mov    (%rsp),%rcx
  409b6e:	e9 6d ff ff ff       	jmpq   409ae0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x370>
  409b73:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409b7a:	00 00 00 00 
  409b7e:	66 90                	xchg   %ax,%ax

0000000000409b80 <fc_solve_apply_moves_order>:
#include "move_funcs_order.h"
#include "set_weights.h"

int fc_solve_apply_moves_order(fcs_moves_order *const moves_order,
    const char *string FCS__PASS_ERR_STR(char *const error_string))
{
  409b80:	41 57                	push   %r15
  409b82:	41 56                	push   %r14
  409b84:	41 55                	push   %r13
  409b86:	41 54                	push   %r12
  409b88:	49 89 fc             	mov    %rdi,%r12
  409b8b:	55                   	push   %rbp
  409b8c:	48 89 f5             	mov    %rsi,%rbp
  409b8f:	53                   	push   %rbx
  409b90:	48 83 ec 38          	sub    $0x38,%rsp
  */

static inline void moves_order__free(fcs_moves_order *moves_order)
{
    const_SLOT(groups, moves_order);
    const_SLOT(num, moves_order);
  409b94:	4c 8b 2f             	mov    (%rdi),%r13
    const_SLOT(groups, moves_order);
  409b97:	4c 8b 77 08          	mov    0x8(%rdi),%r14
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  409b9b:	4d 85 ed             	test   %r13,%r13
  409b9e:	74 24                	je     409bc4 <fc_solve_apply_moves_order+0x44>
  409ba0:	4d 69 ed e8 00 00 00 	imul   $0xe8,%r13,%r13
  409ba7:	4c 89 f3             	mov    %r14,%rbx
  409baa:	4d 01 f5             	add    %r14,%r13
  409bad:	0f 1f 00             	nopl   (%rax)
    {
        free(groups[group_idx].move_funcs);
  409bb0:	48 8b 3b             	mov    (%rbx),%rdi
  409bb3:	48 81 c3 e8 00 00 00 	add    $0xe8,%rbx
  409bba:	e8 91 74 ff ff       	callq  401050 <free@plt>
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  409bbf:	4c 39 eb             	cmp    %r13,%rbx
  409bc2:	75 ec                	jne    409bb0 <fc_solve_apply_moves_order+0x30>
    }
    free(groups);
  409bc4:	4c 89 f7             	mov    %r14,%rdi
  409bc7:	e8 84 74 ff ff       	callq  401050 <free@plt>
    size_t i;
    moves_order__free(moves_order);
    moves_order->groups = SMALLOC(moves_order->groups, MOVES_GROW_BY);
  409bcc:	bf 80 0e 00 00       	mov    $0xe80,%edi
  409bd1:	e8 1a 75 ff ff       	callq  4010f0 <malloc@plt>
    moves_order->groups[moves_order->num].num = 0;
    moves_order->groups[moves_order->num].move_funcs = SMALLOC(
  409bd6:	bf 80 00 00 00       	mov    $0x80,%edi
    moves_order->groups = SMALLOC(moves_order->groups, MOVES_GROW_BY);
  409bdb:	49 89 44 24 08       	mov    %rax,0x8(%r12)
  409be0:	49 89 c5             	mov    %rax,%r13
    moves_order->groups[moves_order->num].num = 0;
  409be3:	48 c7 40 08 00 00 00 	movq   $0x0,0x8(%rax)
  409bea:	00 
    moves_order->groups[moves_order->num].move_funcs = SMALLOC(
  409beb:	e8 00 75 ff ff       	callq  4010f0 <malloc@plt>
        moves_order->groups[moves_order->num].move_funcs, MOVES_GROW_BY);
    moves_order->groups[moves_order->num].shuffling_type = FCS_NO_SHUFFLING;
  409bf0:	41 c7 45 10 00 00 00 	movl   $0x0,0x10(%r13)
  409bf7:	00 

    ++moves_order->num;

    const_AUTO(len, strlen(string));
  409bf8:	48 89 ef             	mov    %rbp,%rdi
    moves_order->groups[moves_order->num].move_funcs = SMALLOC(
  409bfb:	49 89 45 00          	mov    %rax,0x0(%r13)
  409bff:	48 89 c3             	mov    %rax,%rbx
    ++moves_order->num;
  409c02:	49 c7 04 24 01 00 00 	movq   $0x1,(%r12)
  409c09:	00 
    const_AUTO(len, strlen(string));
  409c0a:	e8 61 74 ff ff       	callq  401070 <strlen@plt>
#else
#define SET_ERR(s)
#endif
#endif

    for (i = 0; i < len; i++)
  409c0f:	41 b8 01 00 00 00    	mov    $0x1,%r8d
    const_AUTO(len, strlen(string));
  409c15:	48 89 c6             	mov    %rax,%rsi
  409c18:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
    for (i = 0; i < len; i++)
  409c1d:	31 c0                	xor    %eax,%eax
  409c1f:	48 85 f6             	test   %rsi,%rsi
  409c22:	75 4e                	jne    409c72 <fc_solve_apply_moves_order+0xf2>
  409c24:	e9 f7 03 00 00       	jmpq   40a020 <fc_solve_apply_moves_order+0x4a0>
  409c29:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            }
            moves_order->groups[moves_order->num - 1].shuffling_type = FCS_RAND;
            continue;
        }

        if ((string[i] == ')') || (string[i] == ']'))
  409c30:	80 fa 29             	cmp    $0x29,%dl
  409c33:	0f 84 d7 00 00 00    	je     409d10 <fc_solve_apply_moves_order+0x190>
  409c39:	80 fa 5d             	cmp    $0x5d,%dl
  409c3c:	0f 84 ce 00 00 00    	je     409d10 <fc_solve_apply_moves_order+0x190>
            moves_order->groups[moves_order->num - 1].shuffling_type =
                FCS_NO_SHUFFLING;
            continue;
        }

        if (!(moves_order->groups[moves_order->num - 1].num &
  409c42:	48 8b 43 08          	mov    0x8(%rbx),%rax
  409c46:	48 8b 3b             	mov    (%rbx),%rdi
  409c49:	a8 0f                	test   $0xf,%al
  409c4b:	0f 84 2f 01 00 00    	je     409d80 <fc_solve_apply_moves_order+0x200>
                moves_order->groups[moves_order->num - 1].num + MOVES_GROW_BY);
        }

        moves_order->groups[moves_order->num - 1]
            .move_funcs[moves_order->groups[moves_order->num - 1].num++]
            .idx = fc_solve_string_to_move_num(string[i]);
  409c51:	0f b6 92 00 01 41 00 	movzbl 0x410100(%rdx),%edx
            .move_funcs[moves_order->groups[moves_order->num - 1].num++]
  409c58:	48 8d 48 01          	lea    0x1(%rax),%rcx
  409c5c:	48 89 4b 08          	mov    %rcx,0x8(%rbx)
            .idx = fc_solve_string_to_move_num(string[i]);
  409c60:	48 89 14 c7          	mov    %rdx,(%rdi,%rax,8)
  409c64:	4c 89 f0             	mov    %r14,%rax
    for (i = 0; i < len; i++)
  409c67:	4c 39 74 24 08       	cmp    %r14,0x8(%rsp)
  409c6c:	0f 86 80 00 00 00    	jbe    409cf2 <fc_solve_apply_moves_order+0x172>
        if ((string[i] == '(') || (string[i] == '['))
  409c72:	48 8d 4c 05 00       	lea    0x0(%rbp,%rax,1),%rcx
  409c77:	4d 69 f8 e8 00 00 00 	imul   $0xe8,%r8,%r15
  409c7e:	0f b6 11             	movzbl (%rcx),%edx
  409c81:	4c 8d 70 01          	lea    0x1(%rax),%r14
  409c85:	4b 8d 9c 3d 18 ff ff 	lea    -0xe8(%r13,%r15,1),%rbx
  409c8c:	ff 
  409c8d:	80 fa 28             	cmp    $0x28,%dl
  409c90:	74 05                	je     409c97 <fc_solve_apply_moves_order+0x117>
  409c92:	80 fa 5b             	cmp    $0x5b,%dl
  409c95:	75 99                	jne    409c30 <fc_solve_apply_moves_order+0xb0>
            if (moves_order->groups[moves_order->num - 1].num)
  409c97:	48 83 7b 08 00       	cmpq   $0x0,0x8(%rbx)
  409c9c:	74 43                	je     409ce1 <fc_solve_apply_moves_order+0x161>
                if (!(moves_order->num & (MOVES_GROW_BY - 1)))
  409c9e:	41 f6 c0 0f          	test   $0xf,%r8b
  409ca2:	0f 84 78 02 00 00    	je     409f20 <fc_solve_apply_moves_order+0x3a0>
                moves_order->groups[moves_order->num].num = 0;
  409ca8:	4d 01 ef             	add    %r13,%r15
                    SMALLOC(moves_order->groups[moves_order->num].move_funcs,
  409cab:	bf 80 00 00 00       	mov    $0x80,%edi
  409cb0:	4c 89 44 24 10       	mov    %r8,0x10(%rsp)
                moves_order->groups[moves_order->num].num = 0;
  409cb5:	49 c7 47 08 00 00 00 	movq   $0x0,0x8(%r15)
  409cbc:	00 
                    SMALLOC(moves_order->groups[moves_order->num].move_funcs,
  409cbd:	e8 2e 74 ff ff       	callq  4010f0 <malloc@plt>
                moves_order->num++;
  409cc2:	4c 8b 44 24 10       	mov    0x10(%rsp),%r8
                moves_order->groups[moves_order->num].move_funcs =
  409cc7:	49 89 07             	mov    %rax,(%r15)
                moves_order->num++;
  409cca:	49 83 c0 01          	add    $0x1,%r8
  409cce:	49 69 c0 e8 00 00 00 	imul   $0xe8,%r8,%rax
  409cd5:	4d 89 04 24          	mov    %r8,(%r12)
  409cd9:	49 8d 9c 05 18 ff ff 	lea    -0xe8(%r13,%rax,1),%rbx
  409ce0:	ff 
            moves_order->groups[moves_order->num - 1].shuffling_type = FCS_RAND;
  409ce1:	c7 43 10 01 00 00 00 	movl   $0x1,0x10(%rbx)
  409ce8:	4c 89 f0             	mov    %r14,%rax
    for (i = 0; i < len; i++)
  409ceb:	4c 39 74 24 08       	cmp    %r14,0x8(%rsp)
  409cf0:	77 80                	ja     409c72 <fc_solve_apply_moves_order+0xf2>
        SET_ERR("The Input string is too long.");
        return 4;
    }
#endif

    if (!moves_order->groups[moves_order->num - 1].num)
  409cf2:	48 83 7b 08 00       	cmpq   $0x0,0x8(%rbx)
  409cf7:	0f 84 83 02 00 00    	je     409f80 <fc_solve_apply_moves_order+0x400>
#ifdef FCS_WITH_ERROR_STRS
    error_string[0] = '\0';
#endif

    return 0;
}
  409cfd:	48 83 c4 38          	add    $0x38,%rsp
  409d01:	31 c0                	xor    %eax,%eax
  409d03:	5b                   	pop    %rbx
  409d04:	5d                   	pop    %rbp
  409d05:	41 5c                	pop    %r12
  409d07:	41 5d                	pop    %r13
  409d09:	41 5e                	pop    %r14
  409d0b:	41 5f                	pop    %r15
  409d0d:	c3                   	retq   
  409d0e:	66 90                	xchg   %ax,%ax
            if (string[i + 1] == '=')
  409d10:	42 80 7c 35 00 3d    	cmpb   $0x3d,0x0(%rbp,%r14,1)
  409d16:	0f 84 b4 00 00 00    	je     409dd0 <fc_solve_apply_moves_order+0x250>
            if (moves_order->groups[moves_order->num - 1].num)
  409d1c:	48 83 7b 08 00       	cmpq   $0x0,0x8(%rbx)
  409d21:	74 43                	je     409d66 <fc_solve_apply_moves_order+0x1e6>
                if (!(moves_order->num & (MOVES_GROW_BY - 1)))
  409d23:	41 f6 c0 0f          	test   $0xf,%r8b
  409d27:	0f 84 23 02 00 00    	je     409f50 <fc_solve_apply_moves_order+0x3d0>
                moves_order->groups[moves_order->num].num = 0;
  409d2d:	4d 01 ef             	add    %r13,%r15
                    SMALLOC(moves_order->groups[moves_order->num].move_funcs,
  409d30:	bf 80 00 00 00       	mov    $0x80,%edi
  409d35:	4c 89 44 24 10       	mov    %r8,0x10(%rsp)
                moves_order->groups[moves_order->num].num = 0;
  409d3a:	49 c7 47 08 00 00 00 	movq   $0x0,0x8(%r15)
  409d41:	00 
                    SMALLOC(moves_order->groups[moves_order->num].move_funcs,
  409d42:	e8 a9 73 ff ff       	callq  4010f0 <malloc@plt>
                moves_order->num++;
  409d47:	4c 8b 44 24 10       	mov    0x10(%rsp),%r8
                moves_order->groups[moves_order->num].move_funcs =
  409d4c:	49 89 07             	mov    %rax,(%r15)
                moves_order->num++;
  409d4f:	49 83 c0 01          	add    $0x1,%r8
  409d53:	49 69 c0 e8 00 00 00 	imul   $0xe8,%r8,%rax
  409d5a:	4d 89 04 24          	mov    %r8,(%r12)
  409d5e:	49 8d 9c 05 18 ff ff 	lea    -0xe8(%r13,%rax,1),%rbx
  409d65:	ff 
            moves_order->groups[moves_order->num - 1].shuffling_type =
  409d66:	c7 43 10 00 00 00 00 	movl   $0x0,0x10(%rbx)
  409d6d:	4c 89 f0             	mov    %r14,%rax
  409d70:	e9 f2 fe ff ff       	jmpq   409c67 <fc_solve_apply_moves_order+0xe7>
  409d75:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409d7c:	00 00 00 00 
            moves_order->groups[moves_order->num - 1].move_funcs = SREALLOC(
  409d80:	48 8d 34 c5 80 00 00 	lea    0x80(,%rax,8),%rsi
  409d87:	00 
  409d88:	48 89 4c 24 10       	mov    %rcx,0x10(%rsp)
  409d8d:	e8 de 73 ff ff       	callq  401170 <realloc@plt>
  409d92:	4d 8b 04 24          	mov    (%r12),%r8
  409d96:	48 89 03             	mov    %rax,(%rbx)
  409d99:	4d 8b 6c 24 08       	mov    0x8(%r12),%r13
  409d9e:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
  409da3:	49 69 c0 e8 00 00 00 	imul   $0xe8,%r8,%rax
  409daa:	0f b6 11             	movzbl (%rcx),%edx
  409dad:	49 8d 9c 05 18 ff ff 	lea    -0xe8(%r13,%rax,1),%rbx
  409db4:	ff 
  409db5:	48 8b 3b             	mov    (%rbx),%rdi
  409db8:	48 8b 43 08          	mov    0x8(%rbx),%rax
  409dbc:	e9 90 fe ff ff       	jmpq   409c51 <fc_solve_apply_moves_order+0xd1>
  409dc1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409dc8:	00 00 00 00 
  409dcc:	0f 1f 40 00          	nopl   0x0(%rax)
                const char *const open_paren = strchr(string + i, '(');
  409dd0:	48 8d 54 05 02       	lea    0x2(%rbp,%rax,1),%rdx
  409dd5:	be 28 00 00 00       	mov    $0x28,%esi
  409dda:	4c 89 44 24 18       	mov    %r8,0x18(%rsp)
  409ddf:	48 89 d7             	mov    %rdx,%rdi
  409de2:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  409de7:	e8 74 72 ff ff       	callq  401060 <strchr@plt>
#include <string.h>

static inline bool string_starts_with(
    const char *const str, const char *const prefix, const char *const end)
{
    register const size_t check_len = (size_t)(end - str);
  409dec:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  409df1:	4c 8d 70 01          	lea    0x1(%rax),%r14
  409df5:	48 89 c1             	mov    %rax,%rcx

    return (
        (check_len == strlen(prefix)) && (!strncmp(str, prefix, check_len)));
  409df8:	4c 8b 44 24 18       	mov    0x18(%rsp),%r8
    register const size_t check_len = (size_t)(end - str);
  409dfd:	48 29 d1             	sub    %rdx,%rcx
        (check_len == strlen(prefix)) && (!strncmp(str, prefix, check_len)));
  409e00:	48 83 f9 04          	cmp    $0x4,%rcx
  409e04:	0f 84 c6 00 00 00    	je     409ed0 <fc_solve_apply_moves_order+0x350>
  409e0a:	48 83 f9 03          	cmp    $0x3,%rcx
  409e0e:	0f 85 ac 01 00 00    	jne    409fc0 <fc_solve_apply_moves_order+0x440>
  409e14:	bf 09 f0 40 00       	mov    $0x40f009,%edi
  409e19:	b9 03 00 00 00       	mov    $0x3,%ecx
  409e1e:	48 89 d6             	mov    %rdx,%rsi
  409e21:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  409e23:	0f 97 c0             	seta   %al
  409e26:	1c 00                	sbb    $0x0,%al
  409e28:	84 c0                	test   %al,%al
  409e2a:	0f 85 90 01 00 00    	jne    409fc0 <fc_solve_apply_moves_order+0x440>
                    moves_order->groups[moves_order->num - 1].shuffling_type =
  409e30:	c7 43 10 02 00 00 00 	movl   $0x2,0x10(%rbx)
                const char *const close_paren = strchr(aft_open_paren, ')');
  409e37:	be 29 00 00 00       	mov    $0x29,%esi
  409e3c:	4c 89 f7             	mov    %r14,%rdi
  409e3f:	e8 1c 72 ff ff       	callq  401060 <strchr@plt>
  409e44:	48 89 c2             	mov    %rax,%rdx
                            .weighting.befs_weights.weights);
  409e47:	4c 8d bb b8 00 00 00 	lea    0xb8(%rbx),%r15
  409e4e:	45 31 ed             	xor    %r13d,%r13d
static inline void fc_solve_set_weights(freecell_solver_str_t start_num,
    const freecell_solver_str_t string_end, double *const befs_weights)
{
    for (int i = 0; i < FCS_NUM_BEFS_WEIGHTS; ++i)
    {
        while (*start_num == ',')
  409e51:	41 80 3e 2c          	cmpb   $0x2c,(%r14)
  409e55:	49 63 cd             	movslq %r13d,%rcx
  409e58:	75 10                	jne    409e6a <fc_solve_apply_moves_order+0x2ea>
  409e5a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        {
            start_num++;
  409e60:	49 83 c6 01          	add    $0x1,%r14
        while (*start_num == ',')
  409e64:	41 80 3e 2c          	cmpb   $0x2c,(%r14)
  409e68:	74 f6                	je     409e60 <fc_solve_apply_moves_order+0x2e0>
        }
        if (start_num >= string_end)
  409e6a:	49 39 d6             	cmp    %rdx,%r14
  409e6d:	0f 83 b5 01 00 00    	jae    40a028 <fc_solve_apply_moves_order+0x4a8>
            } while (i < FCS_NUM_BEFS_WEIGHTS);

            return;
        }
        char *end_num;
        const_AUTO(val, strtod(start_num, &end_num));
  409e73:	48 8d 74 24 28       	lea    0x28(%rsp),%rsi
  409e78:	4c 89 f7             	mov    %r14,%rdi
  409e7b:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  409e80:	e8 4b 72 ff ff       	callq  4010d0 <strtod@plt>
        befs_weights[i] = max(val, 0.0);
  409e85:	c5 f9 2f 05 53 76 00 	vcomisd 0x7653(%rip),%xmm0        # 4114e0 <fc_solve_is_parent_buf+0xf20>
  409e8c:	00 
  409e8d:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  409e92:	0f 86 58 01 00 00    	jbe    409ff0 <fc_solve_apply_moves_order+0x470>
  409e98:	c4 a1 7b 11 84 eb b8 	vmovsd %xmm0,0xb8(%rbx,%r13,8)
  409e9f:	00 00 00 
        start_num = end_num;
  409ea2:	49 83 c5 01          	add    $0x1,%r13
  409ea6:	4c 8b 74 24 28       	mov    0x28(%rsp),%r14
    for (int i = 0; i < FCS_NUM_BEFS_WEIGHTS; ++i)
  409eab:	49 83 fd 06          	cmp    $0x6,%r13
  409eaf:	75 a0                	jne    409e51 <fc_solve_apply_moves_order+0x2d1>
  409eb1:	4d 8b 04 24          	mov    (%r12),%r8
  409eb5:	4d 8b 6c 24 08       	mov    0x8(%r12),%r13
  409eba:	4d 69 f8 e8 00 00 00 	imul   $0xe8,%r8,%r15
  409ec1:	4b 8d 9c 3d 18 ff ff 	lea    -0xe8(%r13,%r15,1),%rbx
  409ec8:	ff 
  409ec9:	eb 3d                	jmp    409f08 <fc_solve_apply_moves_order+0x388>
  409ecb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  409ed0:	bf 04 f0 40 00       	mov    $0x40f004,%edi
  409ed5:	48 89 d6             	mov    %rdx,%rsi
  409ed8:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  409eda:	0f 97 c0             	seta   %al
  409edd:	1c 00                	sbb    $0x0,%al
  409edf:	84 c0                	test   %al,%al
  409ee1:	0f 85 d9 00 00 00    	jne    409fc0 <fc_solve_apply_moves_order+0x440>
                    moves_order->groups[moves_order->num - 1].shuffling_type =
  409ee7:	c7 43 10 01 00 00 00 	movl   $0x1,0x10(%rbx)
                const char *const close_paren = strchr(aft_open_paren, ')');
  409eee:	be 29 00 00 00       	mov    $0x29,%esi
  409ef3:	4c 89 f7             	mov    %r14,%rdi
  409ef6:	4c 89 44 24 10       	mov    %r8,0x10(%rsp)
  409efb:	e8 60 71 ff ff       	callq  401060 <strchr@plt>
  409f00:	4c 8b 44 24 10       	mov    0x10(%rsp),%r8
  409f05:	48 89 c2             	mov    %rax,%rdx
                i = close_paren - string;
  409f08:	48 29 ea             	sub    %rbp,%rdx
  409f0b:	4c 8d 72 01          	lea    0x1(%rdx),%r14
  409f0f:	e9 08 fe ff ff       	jmpq   409d1c <fc_solve_apply_moves_order+0x19c>
  409f14:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409f1b:	00 00 00 00 
  409f1f:	90                   	nop
                    moves_order->groups = SREALLOC(
  409f20:	49 8d b7 80 0e 00 00 	lea    0xe80(%r15),%rsi
  409f27:	4c 89 ef             	mov    %r13,%rdi
  409f2a:	e8 41 72 ff ff       	callq  401170 <realloc@plt>
  409f2f:	4d 8b 04 24          	mov    (%r12),%r8
  409f33:	49 89 c5             	mov    %rax,%r13
  409f36:	49 89 44 24 08       	mov    %rax,0x8(%r12)
  409f3b:	4d 69 f8 e8 00 00 00 	imul   $0xe8,%r8,%r15
  409f42:	e9 61 fd ff ff       	jmpq   409ca8 <fc_solve_apply_moves_order+0x128>
  409f47:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  409f4e:	00 00 
                    moves_order->groups = SREALLOC(
  409f50:	49 8d b7 80 0e 00 00 	lea    0xe80(%r15),%rsi
  409f57:	4c 89 ef             	mov    %r13,%rdi
  409f5a:	e8 11 72 ff ff       	callq  401170 <realloc@plt>
  409f5f:	4d 8b 04 24          	mov    (%r12),%r8
  409f63:	49 89 c5             	mov    %rax,%r13
  409f66:	49 89 44 24 08       	mov    %rax,0x8(%r12)
  409f6b:	4d 69 f8 e8 00 00 00 	imul   $0xe8,%r8,%r15
  409f72:	e9 b6 fd ff ff       	jmpq   409d2d <fc_solve_apply_moves_order+0x1ad>
  409f77:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  409f7e:	00 00 
  409f80:	49 83 e8 01          	sub    $0x1,%r8
  409f84:	49 69 c0 e8 00 00 00 	imul   $0xe8,%r8,%rax
  409f8b:	49 8b 5c 05 00       	mov    0x0(%r13,%rax,1),%rbx
        --moves_order->num;
  409f90:	4d 89 04 24          	mov    %r8,(%r12)
        free(moves_order->groups[moves_order->num].move_funcs);
  409f94:	48 89 df             	mov    %rbx,%rdi
  409f97:	e8 b4 70 ff ff       	callq  401050 <free@plt>
        moves_order->groups[moves_order->num].move_funcs = NULL;
  409f9c:	49 69 04 24 e8 00 00 	imul   $0xe8,(%r12),%rax
  409fa3:	00 
  409fa4:	49 03 44 24 08       	add    0x8(%r12),%rax
  409fa9:	48 c7 00 00 00 00 00 	movq   $0x0,(%rax)
    return 0;
  409fb0:	e9 48 fd ff ff       	jmpq   409cfd <fc_solve_apply_moves_order+0x17d>
  409fb5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409fbc:	00 00 00 00 
                const char *const close_paren = strchr(aft_open_paren, ')');
  409fc0:	be 29 00 00 00       	mov    $0x29,%esi
  409fc5:	4c 89 f7             	mov    %r14,%rdi
  409fc8:	4c 89 44 24 10       	mov    %r8,0x10(%rsp)
  409fcd:	e8 8e 70 ff ff       	callq  401060 <strchr@plt>
                if (moves_order->groups[moves_order->num - 1].shuffling_type ==
  409fd2:	83 7b 10 02          	cmpl   $0x2,0x10(%rbx)
                const char *const close_paren = strchr(aft_open_paren, ')');
  409fd6:	48 89 c2             	mov    %rax,%rdx
                if (moves_order->groups[moves_order->num - 1].shuffling_type ==
  409fd9:	4c 8b 44 24 10       	mov    0x10(%rsp),%r8
  409fde:	0f 85 24 ff ff ff    	jne    409f08 <fc_solve_apply_moves_order+0x388>
  409fe4:	e9 5e fe ff ff       	jmpq   409e47 <fc_solve_apply_moves_order+0x2c7>
  409fe9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        befs_weights[i] = max(val, 0.0);
  409ff0:	4a c7 84 eb b8 00 00 	movq   $0x0,0xb8(%rbx,%r13,8)
  409ff7:	00 00 00 00 00 
        start_num = end_num;
  409ffc:	49 83 c5 01          	add    $0x1,%r13
  40a000:	4c 8b 74 24 28       	mov    0x28(%rsp),%r14
    for (int i = 0; i < FCS_NUM_BEFS_WEIGHTS; ++i)
  40a005:	49 83 fd 06          	cmp    $0x6,%r13
  40a009:	0f 85 42 fe ff ff    	jne    409e51 <fc_solve_apply_moves_order+0x2d1>
  40a00f:	e9 9d fe ff ff       	jmpq   409eb1 <fc_solve_apply_moves_order+0x331>
  40a014:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a01b:	00 00 00 00 
  40a01f:	90                   	nop
    for (i = 0; i < len; i++)
  40a020:	45 31 c0             	xor    %r8d,%r8d
  40a023:	e9 68 ff ff ff       	jmpq   409f90 <fc_solve_apply_moves_order+0x410>
                befs_weights[i++] = 0.0;
  40a028:	be 05 00 00 00       	mov    $0x5,%esi
  40a02d:	89 f0                	mov    %esi,%eax
  40a02f:	be 08 00 00 00       	mov    $0x8,%esi
  40a034:	44 29 e8             	sub    %r13d,%eax
  40a037:	83 f9 05             	cmp    $0x5,%ecx
  40a03a:	48 8d 04 c5 08 00 00 	lea    0x8(,%rax,8),%rax
  40a041:	00 
  40a042:	48 0f 4f c6          	cmovg  %rsi,%rax
  40a046:	49 8d 34 cf          	lea    (%r15,%rcx,8),%rsi
  40a04a:	89 c1                	mov    %eax,%ecx
  40a04c:	48 c7 44 0e f8 00 00 	movq   $0x0,-0x8(%rsi,%rcx,1)
  40a053:	00 00 
  40a055:	8d 48 ff             	lea    -0x1(%rax),%ecx
  40a058:	48 89 f7             	mov    %rsi,%rdi
  40a05b:	31 c0                	xor    %eax,%eax
  40a05d:	c1 e9 03             	shr    $0x3,%ecx
  40a060:	f3 48 ab             	rep stos %rax,%es:(%rdi)
            return;
  40a063:	4d 8b 04 24          	mov    (%r12),%r8
  40a067:	4d 8b 6c 24 08       	mov    0x8(%r12),%r13
  40a06c:	4d 69 f8 e8 00 00 00 	imul   $0xe8,%r8,%r15
  40a073:	4b 8d 9c 3d 18 ff ff 	lea    -0xe8(%r13,%r15,1),%rbx
  40a07a:	ff 
  40a07b:	e9 88 fe ff ff       	jmpq   409f08 <fc_solve_apply_moves_order+0x388>

000000000040a080 <freecell_solver_user_set_depth_tests_order>:
}

int DLLEXPORT freecell_solver_user_set_depth_tests_order(
    void *const api_instance, const int min_depth,
    const char *const moves_order FCS__PASS_ERR_STR(char **const error_string))
{
  40a080:	41 57                	push   %r15
  40a082:	41 56                	push   %r14
  40a084:	41 55                	push   %r13
  40a086:	41 54                	push   %r12
  40a088:	55                   	push   %rbp
  40a089:	89 f5                	mov    %esi,%ebp
  40a08b:	53                   	push   %rbx
  40a08c:	48 83 ec 28          	sub    $0x28,%rsp
    return ((fcs_user *const)api_instance)->soft_thread;
  40a090:	4c 8b a7 40 06 00 00 	mov    0x640(%rdi),%r12
        ALLOC_ERROR_STRING(error_string, "Depth is negative.");
        return 1;
    }

    size_t depth_idx = 0;
    if (min_depth > 0)
  40a097:	49 8b 5c 24 10       	mov    0x10(%r12),%rbx
  40a09c:	49 8b 7c 24 18       	mov    0x18(%r12),%rdi
  40a0a1:	85 f6                	test   %esi,%esi
  40a0a3:	0f 84 a7 00 00 00    	je     40a150 <freecell_solver_user_set_depth_tests_order+0xd0>
    {
        for (;; ++depth_idx)
        {
            if (depth_idx == soft_thread->by_depth_moves_order.num - 1)
  40a0a9:	49 89 d8             	mov    %rbx,%r8
  40a0ac:	49 83 e8 01          	sub    $0x1,%r8
  40a0b0:	0f 84 f4 01 00 00    	je     40a2aa <freecell_solver_user_set_depth_tests_order+0x22a>
            {
                break;
            }
            else if (min_depth <=
  40a0b6:	48 8d 47 18          	lea    0x18(%rdi),%rax
  40a0ba:	48 63 f6             	movslq %esi,%rsi
    size_t depth_idx = 0;
  40a0bd:	45 31 ed             	xor    %r13d,%r13d
            else if (min_depth <=
  40a0c0:	48 39 37             	cmp    %rsi,(%rdi)
  40a0c3:	7c 1c                	jl     40a0e1 <freecell_solver_user_set_depth_tests_order+0x61>
  40a0c5:	e9 02 02 00 00       	jmpq   40a2cc <freecell_solver_user_set_depth_tests_order+0x24c>
  40a0ca:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  40a0d0:	48 83 c0 18          	add    $0x18,%rax
  40a0d4:	48 39 70 e8          	cmp    %rsi,-0x18(%rax)
  40a0d8:	0f 8d 62 01 00 00    	jge    40a240 <freecell_solver_user_set_depth_tests_order+0x1c0>
  40a0de:	49 89 cd             	mov    %rcx,%r13
        for (;; ++depth_idx)
  40a0e1:	49 8d 4d 01          	lea    0x1(%r13),%rcx
            if (depth_idx == soft_thread->by_depth_moves_order.num - 1)
  40a0e5:	4c 39 c1             	cmp    %r8,%rcx
  40a0e8:	75 e6                	jne    40a0d0 <freecell_solver_user_set_depth_tests_order+0x50>
  40a0ea:	4c 8d 3c 5b          	lea    (%rbx,%rbx,2),%r15
  40a0ee:	48 8d 43 01          	lea    0x1(%rbx),%rax
  40a0f2:	49 c1 e7 03          	shl    $0x3,%r15
  40a0f6:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  40a0fb:	49 8d 47 18          	lea    0x18(%r15),%rax
  40a0ff:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
        ++depth_idx;
    }

    if (depth_idx == soft_thread->by_depth_moves_order.num)
    {
        soft_thread->by_depth_moves_order.by_depth_moves =
  40a104:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  40a109:	48 89 54 24 18       	mov    %rdx,0x18(%rsp)
            SREALLOC(soft_thread->by_depth_moves_order.by_depth_moves,
  40a10e:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
        soft_thread->by_depth_moves_order.by_depth_moves =
  40a113:	49 89 44 24 10       	mov    %rax,0x10(%r12)
            SREALLOC(soft_thread->by_depth_moves_order.by_depth_moves,
  40a118:	e8 53 70 ff ff       	callq  401170 <realloc@plt>
                ++soft_thread->by_depth_moves_order.num);

        soft_thread->by_depth_moves_order.by_depth_moves[depth_idx]
            .moves_order.num = 0;
        soft_thread->by_depth_moves_order.by_depth_moves[depth_idx]
            .moves_order.groups = NULL;
  40a11d:	48 89 d9             	mov    %rbx,%rcx
  40a120:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
        soft_thread->by_depth_moves_order.by_depth_moves[depth_idx]
  40a125:	4a 8d 3c 38          	lea    (%rax,%r15,1),%rdi
        soft_thread->by_depth_moves_order.by_depth_moves =
  40a129:	49 89 44 24 18       	mov    %rax,0x18(%r12)
            .moves_order.num = 0;
  40a12e:	48 c7 47 08 00 00 00 	movq   $0x0,0x8(%rdi)
  40a135:	00 
            .moves_order.groups = NULL;
  40a136:	48 c7 47 10 00 00 00 	movq   $0x0,0x10(%rdi)
  40a13d:	00 
  40a13e:	e9 2a 01 00 00       	jmpq   40a26d <freecell_solver_user_set_depth_tests_order+0x1ed>
  40a143:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a14a:	00 00 00 00 
  40a14e:	66 90                	xchg   %ax,%ax
    if (depth_idx == soft_thread->by_depth_moves_order.num)
  40a150:	48 85 db             	test   %rbx,%rbx
  40a153:	0f 84 37 01 00 00    	je     40a290 <freecell_solver_user_set_depth_tests_order+0x210>
  40a159:	48 c7 44 24 08 01 00 	movq   $0x1,0x8(%rsp)
  40a160:	00 00 
  40a162:	48 c7 44 24 10 18 00 	movq   $0x18,0x10(%rsp)
  40a169:	00 00 
    {
        soft_thread->by_depth_moves_order.by_depth_moves[depth_idx - 1]
            .max_depth = min_depth;
    }

    soft_thread->by_depth_moves_order.by_depth_moves[depth_idx].max_depth =
  40a16b:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  40a172:	ff ff 7f 
        SSIZE_MAX;

    FCS__DECL_ERR_BUF(static_error_string);
    const int ret_code = fc_solve_apply_moves_order(
  40a175:	48 83 c7 08          	add    $0x8,%rdi
  40a179:	48 89 d6             	mov    %rdx,%rsi
    soft_thread->by_depth_moves_order.by_depth_moves[depth_idx].max_depth =
  40a17c:	48 89 47 f8          	mov    %rax,-0x8(%rdi)
    const int ret_code = fc_solve_apply_moves_order(
  40a180:	e8 fb f9 ff ff       	callq  409b80 <fc_solve_apply_moves_order>
  40a185:	89 44 24 18          	mov    %eax,0x18(%rsp)
                .moves_order),
        moves_order FCS__PASS_ERR_STR(static_error_string));

    SET_ERROR_VAR(error_string, static_error_string);

    for (size_t d = depth_idx + 1; d < soft_thread->by_depth_moves_order.num;
  40a189:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  40a18e:	48 89 c5             	mov    %rax,%rbp
  40a191:	49 39 44 24 10       	cmp    %rax,0x10(%r12)
  40a196:	76 70                	jbe    40a208 <freecell_solver_user_set_depth_tests_order+0x188>
  40a198:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40a19f:	00 
         ++d)
    {
        moves_order__free(
            &(soft_thread->by_depth_moves_order.by_depth_moves[d].moves_order));
  40a1a0:	49 8b 54 24 18       	mov    0x18(%r12),%rdx
  40a1a5:	48 8d 44 6d 00       	lea    0x0(%rbp,%rbp,2),%rax
  40a1aa:	4c 8d 3c c2          	lea    (%rdx,%rax,8),%r15
    const_SLOT(num, moves_order);
  40a1ae:	49 8b 5f 08          	mov    0x8(%r15),%rbx
    const_SLOT(groups, moves_order);
  40a1b2:	4d 8b 77 10          	mov    0x10(%r15),%r14
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40a1b6:	48 85 db             	test   %rbx,%rbx
  40a1b9:	74 2a                	je     40a1e5 <freecell_solver_user_set_depth_tests_order+0x165>
  40a1bb:	48 69 db e8 00 00 00 	imul   $0xe8,%rbx,%rbx
  40a1c2:	4d 89 f5             	mov    %r14,%r13
  40a1c5:	4c 01 f3             	add    %r14,%rbx
  40a1c8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40a1cf:	00 
        free(groups[group_idx].move_funcs);
  40a1d0:	49 8b 7d 00          	mov    0x0(%r13),%rdi
  40a1d4:	49 81 c5 e8 00 00 00 	add    $0xe8,%r13
  40a1db:	e8 70 6e ff ff       	callq  401050 <free@plt>
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40a1e0:	49 39 dd             	cmp    %rbx,%r13
  40a1e3:	75 eb                	jne    40a1d0 <freecell_solver_user_set_depth_tests_order+0x150>
    free(groups);
  40a1e5:	4c 89 f7             	mov    %r14,%rdi
         ++d)
  40a1e8:	48 83 c5 01          	add    $0x1,%rbp
  40a1ec:	e8 5f 6e ff ff       	callq  401050 <free@plt>
    moves_order->groups = NULL;
  40a1f1:	49 c7 47 10 00 00 00 	movq   $0x0,0x10(%r15)
  40a1f8:	00 
    moves_order->num = 0;
  40a1f9:	49 c7 47 08 00 00 00 	movq   $0x0,0x8(%r15)
  40a200:	00 
    for (size_t d = depth_idx + 1; d < soft_thread->by_depth_moves_order.num;
  40a201:	49 39 6c 24 10       	cmp    %rbp,0x10(%r12)
  40a206:	77 98                	ja     40a1a0 <freecell_solver_user_set_depth_tests_order+0x120>
    }

    soft_thread->by_depth_moves_order.by_depth_moves =
        SREALLOC(soft_thread->by_depth_moves_order.by_depth_moves,
  40a208:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  40a20d:	49 8b 7c 24 18       	mov    0x18(%r12),%rdi
  40a212:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  40a217:	49 89 44 24 10       	mov    %rax,0x10(%r12)
  40a21c:	e8 4f 6f ff ff       	callq  401170 <realloc@plt>
    soft_thread->by_depth_moves_order.by_depth_moves =
  40a221:	49 89 44 24 18       	mov    %rax,0x18(%r12)
            soft_thread->by_depth_moves_order.num = depth_idx + 1);

    return ret_code;
}
  40a226:	8b 44 24 18          	mov    0x18(%rsp),%eax
  40a22a:	48 83 c4 28          	add    $0x28,%rsp
  40a22e:	5b                   	pop    %rbx
  40a22f:	5d                   	pop    %rbp
  40a230:	41 5c                	pop    %r12
  40a232:	41 5d                	pop    %r13
  40a234:	41 5e                	pop    %r14
  40a236:	41 5f                	pop    %r15
  40a238:	c3                   	retq   
  40a239:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  40a240:	49 8d 4d 02          	lea    0x2(%r13),%rcx
  40a244:	4c 8d 3c 49          	lea    (%rcx,%rcx,2),%r15
  40a248:	49 8d 45 03          	lea    0x3(%r13),%rax
  40a24c:	49 c1 e7 03          	shl    $0x3,%r15
  40a250:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  40a255:	49 8d 47 18          	lea    0x18(%r15),%rax
  40a259:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
    if (depth_idx == soft_thread->by_depth_moves_order.num)
  40a25e:	48 39 cb             	cmp    %rcx,%rbx
  40a261:	0f 84 9d fe ff ff    	je     40a104 <freecell_solver_user_set_depth_tests_order+0x84>
  40a267:	48 89 f8             	mov    %rdi,%rax
  40a26a:	4c 01 ff             	add    %r15,%rdi
    if (depth_idx > 0)
  40a26d:	48 85 c9             	test   %rcx,%rcx
  40a270:	0f 84 f5 fe ff ff    	je     40a16b <freecell_solver_user_set_depth_tests_order+0xeb>
  40a276:	48 63 f5             	movslq %ebp,%rsi
            .max_depth = min_depth;
  40a279:	4a 89 74 38 e8       	mov    %rsi,-0x18(%rax,%r15,1)
  40a27e:	e9 e8 fe ff ff       	jmpq   40a16b <freecell_solver_user_set_depth_tests_order+0xeb>
  40a283:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a28a:	00 00 00 00 
  40a28e:	66 90                	xchg   %ax,%ax
    if (depth_idx == soft_thread->by_depth_moves_order.num)
  40a290:	48 c7 44 24 10 18 00 	movq   $0x18,0x10(%rsp)
  40a297:	00 00 
  40a299:	45 31 ff             	xor    %r15d,%r15d
  40a29c:	48 c7 44 24 08 01 00 	movq   $0x1,0x8(%rsp)
  40a2a3:	00 00 
  40a2a5:	e9 5a fe ff ff       	jmpq   40a104 <freecell_solver_user_set_depth_tests_order+0x84>
            if (depth_idx == soft_thread->by_depth_moves_order.num - 1)
  40a2aa:	48 c7 44 24 10 30 00 	movq   $0x30,0x10(%rsp)
  40a2b1:	00 00 
  40a2b3:	41 bf 18 00 00 00    	mov    $0x18,%r15d
  40a2b9:	bb 01 00 00 00       	mov    $0x1,%ebx
  40a2be:	48 c7 44 24 08 02 00 	movq   $0x2,0x8(%rsp)
  40a2c5:	00 00 
  40a2c7:	e9 38 fe ff ff       	jmpq   40a104 <freecell_solver_user_set_depth_tests_order+0x84>
            else if (min_depth <=
  40a2cc:	48 89 f8             	mov    %rdi,%rax
  40a2cf:	41 bf 18 00 00 00    	mov    $0x18,%r15d
  40a2d5:	48 83 c7 18          	add    $0x18,%rdi
  40a2d9:	48 c7 44 24 10 30 00 	movq   $0x30,0x10(%rsp)
  40a2e0:	00 00 
  40a2e2:	48 c7 44 24 08 02 00 	movq   $0x2,0x8(%rsp)
  40a2e9:	00 00 
  40a2eb:	eb 8c                	jmp    40a279 <freecell_solver_user_set_depth_tests_order+0x1f9>
  40a2ed:	0f 1f 00             	nopl   (%rax)

000000000040a2f0 <resume_solution>:
    continue
#else
#define BUMP_CURR_INST() break
#endif
static inline fc_solve_solve_process_ret_t resume_solution(fcs_user *const user)
{
  40a2f0:	55                   	push   %rbp
  40a2f1:	48 89 e5             	mov    %rsp,%rbp
  40a2f4:	41 57                	push   %r15
  40a2f6:	41 56                	push   %r14
  40a2f8:	41 55                	push   %r13
  40a2fa:	41 54                	push   %r12
  40a2fc:	53                   	push   %rbx
  40a2fd:	48 83 e4 e0          	and    $0xffffffffffffffe0,%rsp
  40a301:	48 81 ec 80 01 00 00 	sub    $0x180,%rsp
  40a308:	8b 87 b8 05 00 00    	mov    0x5b8(%rdi),%eax
  40a30e:	48 89 bc 24 e8 00 00 	mov    %rdi,0xe8(%rsp)
  40a315:	00 

        flare_item *const flare = current_plan_item->flare;
#else
        flare_item *const flare = &(instance_item->single_flare);

        if (flare->ret_code == FCS_STATE_WAS_SOLVED)
  40a316:	85 c0                	test   %eax,%eax
  40a318:	0f 84 c8 0d 00 00    	je     40b0e6 <resume_solution+0xdf6>
            user->init_num_checked_states = flare->obj_stats;

            ret = user->ret_code = FCS_STATE_WAS_SOLVED;
            break;
        }
        else if (flare->ret_code == FCS_STATE_IS_NOT_SOLVEABLE)
  40a31e:	83 f8 01             	cmp    $0x1,%eax
  40a321:	0f 84 8b 00 00 00    	je     40a3b2 <resume_solution+0xc2>

        SET_ACTIVE_FLARE(user, flare);
        const bool is_start_of_flare_solving =
            (flare->ret_code == FCS_STATE_NOT_BEGAN_YET);

        if (is_start_of_flare_solving)
  40a327:	83 f8 09             	cmp    $0x9,%eax
  40a32a:	0f 84 60 26 00 00    	je     40c990 <resume_solution+0x26a0>
                                   user->iterations_board_started_at
                                       .num_checked_states));
        }
#endif

        user->init_num_checked_states.num_checked_states =
  40a330:	48 8b 8c 24 e8 00 00 	mov    0xe8(%rsp),%rcx
  40a337:	00 
  40a338:	48 8b 11             	mov    (%rcx),%rdx
  40a33b:	48 89 91 d0 05 00 00 	mov    %rdx,0x5d0(%rcx)
#endif
            );
        }

        const bool was_run_now =
            ((flare->ret_code == FCS_STATE_SUSPEND_PROCESS) ||
  40a342:	8d 50 fb             	lea    -0x5(%rax),%edx
                (flare->ret_code == FCS_STATE_NOT_BEGAN_YET));

        if (was_run_now)
  40a345:	83 e2 fb             	and    $0xfffffffb,%edx
  40a348:	0f 84 c2 00 00 00    	je     40a410 <resume_solution+0x120>
        {
            user->all_instances_were_suspended = FALSE;
        }
#endif

        flare->obj_stats.num_checked_states = instance->i__num_checked_states;
  40a34e:	48 8b b4 24 e8 00 00 	mov    0xe8(%rsp),%rsi
  40a355:	00 
  40a356:	48 8b 0e             	mov    (%rsi),%rcx
#ifndef FCS_DISABLE_NUM_STORED_STATES
        flare->obj_stats.num_states_in_collection =
            instance->num_states_in_collection;
#endif
        const_AUTO(delta, flare->obj_stats.num_checked_states -
  40a359:	48 89 ca             	mov    %rcx,%rdx
  40a35c:	48 2b 96 d0 05 00 00 	sub    0x5d0(%rsi),%rdx
        flare->obj_stats.num_checked_states = instance->i__num_checked_states;
  40a363:	c4 e1 f9 6e f9       	vmovq  %rcx,%xmm7
  40a368:	48 89 8c 24 d0 00 00 	mov    %rcx,0xd0(%rsp)
  40a36f:	00 
                              user->init_num_checked_states.num_checked_states);
        user->iterations_board_started_at.num_checked_states += delta;
  40a370:	48 03 96 c8 05 00 00 	add    0x5c8(%rsi),%rdx
        flare->obj_stats.num_checked_states = instance->i__num_checked_states;
  40a377:	c4 e3 c1 22 c2 01    	vpinsrq $0x1,%rdx,%xmm7,%xmm0
            flare->obj_stats.num_states_in_collection -
            user->init_num_checked_states.num_states_in_collection;
#endif
        user->init_num_checked_states = flare->obj_stats;

        if (user->ret_code == FCS_STATE_WAS_SOLVED)
  40a37d:	8b 96 38 06 00 00    	mov    0x638(%rsi),%edx
        flare->obj_stats.num_checked_states = instance->i__num_checked_states;
  40a383:	c5 f8 11 86 c0 05 00 	vmovups %xmm0,0x5c0(%rsi)
  40a38a:	00 
        user->init_num_checked_states = flare->obj_stats;
  40a38b:	c5 f9 d6 86 d0 05 00 	vmovq  %xmm0,0x5d0(%rsi)
  40a392:	00 
        if (user->ret_code == FCS_STATE_WAS_SOLVED)
  40a393:	85 d2                	test   %edx,%edx
  40a395:	75 0a                	jne    40a3a1 <resume_solution+0xb1>
                    get_flare_move_count(user, flare)))
            {
                instance_item->minimal_flare = flare;
            }
#endif
            ret = user->ret_code = FCS_STATE_IS_NOT_SOLVEABLE;
  40a397:	c7 86 38 06 00 00 01 	movl   $0x1,0x638(%rsi)
  40a39e:	00 00 00 
        if (flare->ret_code == FCS_STATE_WAS_SOLVED)
  40a3a1:	85 c0                	test   %eax,%eax
  40a3a3:	0f 84 3d 0d 00 00    	je     40b0e6 <resume_solution+0xdf6>
        else if (flare->ret_code == FCS_STATE_IS_NOT_SOLVEABLE)
  40a3a9:	83 f8 01             	cmp    $0x1,%eax
  40a3ac:	0f 85 75 ff ff ff    	jne    40a327 <resume_solution+0x37>
    if (!flare->instance_is_ready)
  40a3b2:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40a3b9:	00 
  40a3ba:	80 b8 bc 05 00 00 00 	cmpb   $0x0,0x5bc(%rax)
  40a3c1:	0f 84 10 32 00 00    	je     40d5d7 <resume_solution+0x32e7>
        user->init_num_checked_states = initial_stats;
  40a3c7:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40a3ce:	00 
    flare->obj_stats = initial_stats;
  40a3cf:	41 bd 01 00 00 00    	mov    $0x1,%r13d
        user->init_num_checked_states = initial_stats;
  40a3d5:	48 c7 80 d0 05 00 00 	movq   $0x0,0x5d0(%rax)
  40a3dc:	00 00 00 00 
        flare->ret_code = FCS_STATE_NOT_BEGAN_YET;
  40a3e0:	c7 80 b8 05 00 00 09 	movl   $0x9,0x5b8(%rax)
  40a3e7:	00 00 00 
    flare->obj_stats = initial_stats;
  40a3ea:	48 c7 80 c0 05 00 00 	movq   $0x0,0x5c0(%rax)
  40a3f1:	00 00 00 00 
    return (
        user->all_instances_were_suspended ? FCS_STATE_SUSPEND_PROCESS : ret);
#else
    return ret;
#endif
}
  40a3f5:	48 8d 65 d8          	lea    -0x28(%rbp),%rsp
  40a3f9:	44 89 e8             	mov    %r13d,%eax
  40a3fc:	5b                   	pop    %rbx
  40a3fd:	41 5c                	pop    %r12
  40a3ff:	41 5d                	pop    %r13
  40a401:	41 5e                	pop    %r14
  40a403:	41 5f                	pop    %r15
  40a405:	5d                   	pop    %rbp
  40a406:	c3                   	retq   
  40a407:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40a40e:	00 00 
    fc_solve_solve_process_ret_t ret = FCS_STATE_SUSPEND_PROCESS;
  40a410:	41 bd 05 00 00 00    	mov    $0x5,%r13d
  40a416:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40a41d:	00 00 00 
        while (instance->num_hard_threads_finished < NUM_HARD_THREADS())
  40a420:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40a427:	00 
  40a428:	48 8b 80 40 05 00 00 	mov    0x540(%rax),%rax
  40a42f:	48 85 c0             	test   %rax,%rax
  40a432:	0f 85 b8 2e 00 00    	jne    40d2f0 <resume_solution+0x3000>
    const size_t prelude_num_items = HT_FIELD(hard_thread, prelude_num_items);
  40a438:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40a43f:	00 
    fc_solve_solve_process_ret_t ret = FCS_STATE_SUSPEND_PROCESS;
  40a440:	41 bd 05 00 00 00    	mov    $0x5,%r13d
    const size_t prelude_num_items = HT_FIELD(hard_thread, prelude_num_items);
  40a446:	48 8b b8 00 05 00 00 	mov    0x500(%rax),%rdi
    const fc_solve_prelude_item *const prelude = HT_FIELD(hard_thread, prelude);
  40a44d:	48 8b 88 10 05 00 00 	mov    0x510(%rax),%rcx
    const size_t prelude_num_items = HT_FIELD(hard_thread, prelude_num_items);
  40a454:	48 89 7c 24 58       	mov    %rdi,0x58(%rsp)
    const int_fast32_t num_soft_threads =
  40a459:	48 8b b8 20 05 00 00 	mov    0x520(%rax),%rdi
    const fc_solve_prelude_item *const prelude = HT_FIELD(hard_thread, prelude);
  40a460:	48 89 4c 24 50       	mov    %rcx,0x50(%rsp)
  40a465:	48 63 88 28 05 00 00 	movslq 0x528(%rax),%rcx
    const int_fast32_t num_soft_threads =
  40a46c:	48 89 bc 24 88 00 00 	mov    %rdi,0x88(%rsp)
  40a473:	00 
    fcs_soft_thread *const soft_threads = HT_FIELD(hard_thread, soft_threads);
  40a474:	48 8b b8 c0 00 00 00 	mov    0xc0(%rax),%rdi
  40a47b:	48 89 7c 24 78       	mov    %rdi,0x78(%rsp)
    while (HT_FIELD(hard_thread, num_soft_threads_finished) < num_soft_threads)
  40a480:	48 39 8c 24 88 00 00 	cmp    %rcx,0x88(%rsp)
  40a487:	00 
  40a488:	0f 8e e5 0b 00 00    	jle    40b073 <resume_solution+0xd83>
        fcs_soft_thread *const soft_thread = &(soft_threads[*st_idx_ptr]);
  40a48e:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40a495:	00 
  40a496:	48 8b 7c 24 78       	mov    0x78(%rsp),%rdi
  40a49b:	48 8b 80 d0 00 00 00 	mov    0xd0(%rax),%rax
  40a4a2:	48 69 d0 f8 01 00 00 	imul   $0x1f8,%rax,%rdx
  40a4a9:	4c 8d 3c 17          	lea    (%rdi,%rdx,1),%r15
        if (STRUCT_QUERY_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED))
  40a4ad:	41 80 bf e0 01 00 00 	cmpb   $0x0,0x1e0(%r15)
  40a4b4:	00 
  40a4b5:	0f 85 25 1a 00 00    	jne    40bee0 <resume_solution+0x1bf0>
        if (!STRUCT_QUERY_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED))
  40a4bb:	41 80 bf e1 01 00 00 	cmpb   $0x0,0x1e1(%r15)
  40a4c2:	00 
    fcs_instance *const instance = fcs_st_instance(soft_thread);
  40a4c3:	4d 8b 27             	mov    (%r15),%r12
        if (!STRUCT_QUERY_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED))
  40a4c6:	0f 84 44 16 00 00    	je     40bb10 <resume_solution+0x1820>
    switch (soft_thread->super_method_type)
  40a4cc:	41 8b 4f 20          	mov    0x20(%r15),%ecx
    const bool scans_synergy =
  40a4d0:	41 0f b6 84 24 b8 00 	movzbl 0xb8(%r12),%eax
  40a4d7:	00 00 
  40a4d9:	85 c9                	test   %ecx,%ecx
  40a4db:	0f 85 3f 09 00 00    	jne    40ae20 <resume_solution+0xb30>
    const bool scans_synergy =
  40a4e1:	88 44 24 47          	mov    %al,0x47(%rsp)
    const bool is_a_complete_scan =
  40a4e5:	41 0f b6 87 e2 01 00 	movzbl 0x1e2(%r15),%eax
  40a4ec:	00 
    var_AUTO(
  40a4ed:	49 8b 5f 30          	mov    0x30(%r15),%rbx
    ssize_t dfs_max_depth = DFS_VAR(soft_thread, dfs_max_depth);
  40a4f1:	49 8b 7f 28          	mov    0x28(%r15),%rdi
    const_AUTO(soft_thread_id, soft_thread->id);
  40a4f5:	41 8b 4f 08          	mov    0x8(%r15),%ecx
    const bool is_a_complete_scan =
  40a4f9:	88 44 24 40          	mov    %al,0x40(%rsp)
    var_AUTO(
  40a4fd:	49 8b 47 38          	mov    0x38(%r15),%rax
    ssize_t dfs_max_depth = DFS_VAR(soft_thread, dfs_max_depth);
  40a501:	48 89 7c 24 68       	mov    %rdi,0x68(%rsp)
    const_SLOT(enable_pruning, soft_thread);
  40a506:	41 0f b6 bf f0 01 00 	movzbl 0x1f0(%r15),%edi
  40a50d:	00 
    var_AUTO(
  40a50e:	48 69 d0 b0 00 00 00 	imul   $0xb0,%rax,%rdx
    const_SLOT(enable_pruning, soft_thread);
  40a515:	40 88 7c 24 38       	mov    %dil,0x38(%rsp)
    var_AUTO(
  40a51a:	48 01 d3             	add    %rdx,%rbx
    fcs_derived_states_list derived_list =
  40a51d:	c5 fa 6f 7b 08       	vmovdqu 0x8(%rbx),%xmm7
    PTR_STATE = the_soft_dfs_info->state;
  40a522:	4c 8b 1b             	mov    (%rbx),%r11
    fcs_derived_states_list derived_list =
  40a525:	c5 f8 29 bc 24 00 01 	vmovaps %xmm7,0x100(%rsp)
  40a52c:	00 00 
    const_AUTO(
  40a52e:	49 8b 57 58          	mov    0x58(%r15),%rdx
    const_AUTO(max_num_states, calc_ht_max_num_states(instance, hard_thread));
  40a532:	49 8b b4 24 c8 00 00 	mov    0xc8(%r12),%rsi
  40a539:	00 
    FCS_ASSIGN_STATE_KEY();
  40a53a:	49 8d 7b 48          	lea    0x48(%r11),%rdi
  40a53e:	4c 89 9c 24 b8 00 00 	mov    %r11,0xb8(%rsp)
  40a545:	00 
  40a546:	48 89 bc 24 b0 00 00 	mov    %rdi,0xb0(%rsp)
  40a54d:	00 
    for (; (DEPTH() >= GET_DEPTH(curr_by_depth_unit)); ++curr_by_depth_unit)
  40a54e:	48 8b 3a             	mov    (%rdx),%rdi
    const_AUTO(
  40a551:	48 89 94 24 80 00 00 	mov    %rdx,0x80(%rsp)
  40a558:	00 
    const_AUTO(max_num_states, calc_ht_max_num_states(instance, hard_thread));
  40a559:	48 89 74 24 30       	mov    %rsi,0x30(%rsp)
    for (; (DEPTH() >= GET_DEPTH(curr_by_depth_unit)); ++curr_by_depth_unit)
  40a55e:	48 89 bc 24 a0 00 00 	mov    %rdi,0xa0(%rsp)
  40a565:	00 
  40a566:	48 39 c7             	cmp    %rax,%rdi
  40a569:	0f 8f 11 23 00 00    	jg     40c880 <resume_solution+0x2590>
  40a56f:	90                   	nop
  40a570:	48 83 c2 18          	add    $0x18,%rdx
  40a574:	48 8b 32             	mov    (%rdx),%rsi
  40a577:	48 39 f0             	cmp    %rsi,%rax
  40a57a:	7d f4                	jge    40a570 <resume_solution+0x280>
  40a57c:	48 89 94 24 d0 00 00 	mov    %rdx,0xd0(%rsp)
  40a583:	00 
  40a584:	48 89 b4 24 a0 00 00 	mov    %rsi,0xa0(%rsp)
  40a58b:	00 
    RECALC_BY_DEPTH_LIMITS();
  40a58c:	48 c7 84 24 c8 00 00 	movq   $0x0,0xc8(%rsp)
  40a593:	00 00 00 00 00 
  40a598:	48 39 94 24 80 00 00 	cmp    %rdx,0x80(%rsp)
  40a59f:	00 
  40a5a0:	74 0c                	je     40a5ae <resume_solution+0x2be>
  40a5a2:	48 8b 72 e8          	mov    -0x18(%rdx),%rsi
  40a5a6:	48 89 b4 24 c8 00 00 	mov    %rsi,0xc8(%rsp)
  40a5ad:	00 
  40a5ae:	48 8b b4 24 d0 00 00 	mov    0xd0(%rsp),%rsi
  40a5b5:	00 
  40a5b6:	ba 01 00 00 00       	mov    $0x1,%edx
  40a5bb:	4d 89 fd             	mov    %r15,%r13
  40a5be:	4c 89 a4 24 90 00 00 	mov    %r12,0x90(%rsp)
  40a5c5:	00 
    fcs_moves_group_kind local_shuffling_type = FCS_NO_SHUFFLING;
  40a5c6:	c7 44 24 70 00 00 00 	movl   $0x0,0x70(%rsp)
  40a5cd:	00 
  40a5ce:	4d 89 dc             	mov    %r11,%r12
        if (unlikely(DEPTH() + 1 >= dfs_max_depth))
  40a5d1:	48 83 c0 01          	add    $0x1,%rax
    RECALC_BY_DEPTH_LIMITS();
  40a5d5:	48 8b 7e 08          	mov    0x8(%rsi),%rdi
  40a5d9:	48 8b 76 10          	mov    0x10(%rsi),%rsi
  40a5dd:	48 89 bc 24 e0 00 00 	mov    %rdi,0xe0(%rsp)
  40a5e4:	00 
                (!is_scan_visited(single_derived_state, soft_thread_id)))
  40a5e5:	89 cf                	mov    %ecx,%edi
  40a5e7:	83 e1 07             	and    $0x7,%ecx
  40a5ea:	d3 e2                	shl    %cl,%edx
  40a5ec:	c1 ff 03             	sar    $0x3,%edi
    RECALC_BY_DEPTH_LIMITS();
  40a5ef:	48 89 b4 24 c0 00 00 	mov    %rsi,0xc0(%rsp)
  40a5f6:	00 
                (!is_scan_visited(single_derived_state, soft_thread_id)))
  40a5f7:	89 7c 24 24          	mov    %edi,0x24(%rsp)
  40a5fb:	89 54 24 48          	mov    %edx,0x48(%rsp)
    (FCS_S_SCAN_VISITED(ptr_state))[scan_id >> FCS_CHAR_BIT_SIZE_LOG2] |=
  40a5ff:	88 54 24 46          	mov    %dl,0x46(%rsp)
        if (unlikely(DEPTH() + 1 >= dfs_max_depth))
  40a603:	48 3b 44 24 68       	cmp    0x68(%rsp),%rax
  40a608:	0f 8d ca 02 00 00    	jge    40a8d8 <resume_solution+0x5e8>
  40a60e:	66 90                	xchg   %ax,%ax
        if (the_soft_dfs_info->current_state_index == derived_list.num_states)
  40a610:	48 8b 43 20          	mov    0x20(%rbx),%rax
  40a614:	48 8b 8c 24 00 01 00 	mov    0x100(%rsp),%rcx
  40a61b:	00 
  40a61c:	48 39 c8             	cmp    %rcx,%rax
  40a61f:	0f 85 bb 1c 00 00    	jne    40c2e0 <resume_solution+0x1ff0>
            if (the_soft_dfs_info->move_func_list_idx ==
  40a625:	4c 8b 73 18          	mov    0x18(%rbx),%r14
  40a629:	4c 3b b4 24 e0 00 00 	cmp    0xe0(%rsp),%r14
  40a630:	00 
  40a631:	0f 84 69 1b 00 00    	je     40c1a0 <resume_solution+0x1eb0>
            derived_list.num_states = 0;
  40a637:	48 c7 84 24 00 01 00 	movq   $0x0,0x100(%rsp)
  40a63e:	00 00 00 00 00 
            if ((the_soft_dfs_info->move_func_idx == 0) &&
  40a643:	4c 89 f0             	mov    %r14,%rax
  40a646:	48 0b 43 28          	or     0x28(%rbx),%rax
  40a64a:	0f 85 20 1d 00 00    	jne    40c370 <resume_solution+0x2080>
    fcs__should_state_be_pruned__state(ptr_state)
#else
static inline bool fcs__should_state_be_pruned(
    const bool enable_pruning, const fcs_collectible_state *const ptr_state)
{
    return (enable_pruning && fcs__should_state_be_pruned__state(ptr_state));
  40a650:	80 7c 24 38 00       	cmpb   $0x0,0x38(%rsp)
  40a655:	0f 84 d5 18 00 00    	je     40bf30 <resume_solution+0x1c40>
  40a65b:	41 f6 44 24 56 10    	testb  $0x10,0x56(%r12)
  40a661:	0f 85 c9 18 00 00    	jne    40bf30 <resume_solution+0x1c40>
                        fc_solve_sfs_raymond_prune(soft_thread, pass);
  40a667:	48 8b b4 24 b8 00 00 	mov    0xb8(%rsp),%rsi
  40a66e:	00 
  40a66f:	4c 89 ef             	mov    %r13,%rdi
  40a672:	48 8b 94 24 b0 00 00 	mov    0xb0(%rsp),%rdx
  40a679:	00 
  40a67a:	e8 c1 80 ff ff       	callq  402740 <fc_solve_sfs_raymond_prune>
  40a67f:	49 89 c6             	mov    %rax,%r14
                    if (derived)
  40a682:	48 85 c0             	test   %rax,%rax
  40a685:	0f 84 a5 18 00 00    	je     40bf30 <resume_solution+0x1c40>
                        the_soft_dfs_info->move_func_list_idx =
  40a68b:	48 8b 84 24 e0 00 00 	mov    0xe0(%rsp),%rax
  40a692:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  40a693:	31 f6                	xor    %esi,%esi
  40a695:	48 89 43 18          	mov    %rax,0x18(%rbx)
  40a699:	48 8b 84 24 08 01 00 	mov    0x108(%rsp),%rax
  40a6a0:	00 
  40a6a1:	48 8b bc 24 00 01 00 	mov    0x100(%rsp),%rdi
  40a6a8:	00 
  40a6a9:	48 85 c0             	test   %rax,%rax
  40a6ac:	40 0f 95 c6          	setne  %sil
  40a6b0:	48 01 fe             	add    %rdi,%rsi
  40a6b3:	40 f6 c6 0f          	test   $0xf,%sil
  40a6b7:	0f 84 13 1a 00 00    	je     40c0d0 <resume_solution+0x1de0>
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  40a6bd:	48 8d 57 01          	lea    0x1(%rdi),%rdx
  40a6c1:	48 c1 e7 04          	shl    $0x4,%rdi
  40a6c5:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  40a6c9:	48 01 f8             	add    %rdi,%rax
  40a6cc:	48 89 94 24 00 01 00 	mov    %rdx,0x100(%rsp)
  40a6d3:	00 
                        if (the_soft_dfs_info
  40a6d4:	48 83 7b 30 00       	cmpq   $0x0,0x30(%rbx)
  40a6d9:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  40a6dd:	4c 89 30             	mov    %r14,(%rax)
  40a6e0:	48 8b 43 38          	mov    0x38(%rbx),%rax
  40a6e4:	0f 84 c6 19 00 00    	je     40c0b0 <resume_solution+0x1dc0>
                        the_soft_dfs_info->derived_states_random_indexes[0]
  40a6ea:	4c 8b 73 18          	mov    0x18(%rbx),%r14
                            .idx = 0;
  40a6ee:	c7 00 00 00 00 00    	movl   $0x0,(%rax)
                &(THE_MOVE_FUNCS_LIST.groups[orig_idx].weighting);
  40a6f4:	49 69 c6 e8 00 00 00 	imul   $0xe8,%r14,%rax
  40a6fb:	48 03 84 24 c0 00 00 	add    0xc0(%rsp),%rax
  40a702:	00 
  40a703:	48 89 84 24 a8 00 00 	mov    %rax,0xa8(%rsp)
  40a70a:	00 
            if (the_soft_dfs_info->move_func_list_idx < THE_MOVE_FUNCS_LIST.num)
  40a70b:	4c 39 b4 24 e0 00 00 	cmp    %r14,0xe0(%rsp)
  40a712:	00 
  40a713:	0f 87 d7 05 00 00    	ja     40acf0 <resume_solution+0xa00>
            const_AUTO(num_states, derived_list.num_states);
  40a719:	4c 8b bc 24 00 01 00 	mov    0x100(%rsp),%r15
  40a720:	00 
            if (num_states >
  40a721:	48 8b 7b 38          	mov    0x38(%rbx),%rdi
  40a725:	4c 3b 7b 30          	cmp    0x30(%rbx),%r15
  40a729:	76 18                	jbe    40a743 <resume_solution+0x453>
                the_soft_dfs_info->derived_states_random_indexes_max_size =
  40a72b:	4c 89 7b 30          	mov    %r15,0x30(%rbx)
                the_soft_dfs_info->derived_states_random_indexes = SREALLOC(
  40a72f:	4a 8d 34 fd 00 00 00 	lea    0x0(,%r15,8),%rsi
  40a736:	00 
  40a737:	e8 34 6a ff ff       	callq  401170 <realloc@plt>
  40a73c:	48 89 c7             	mov    %rax,%rdi
  40a73f:	48 89 43 38          	mov    %rax,0x38(%rbx)
            for (size_t i = 0; i < num_states; i++)
  40a743:	48 8b 84 24 08 01 00 	mov    0x108(%rsp),%rax
  40a74a:	00 
  40a74b:	48 89 84 24 98 00 00 	mov    %rax,0x98(%rsp)
  40a752:	00 
  40a753:	4d 85 ff             	test   %r15,%r15
  40a756:	74 48                	je     40a7a0 <resume_solution+0x4b0>
                local_shuffling_type =
  40a758:	31 c0                	xor    %eax,%eax
  40a75a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                rand_array[i].idx = i;
  40a760:	89 04 c7             	mov    %eax,(%rdi,%rax,8)
            for (size_t i = 0; i < num_states; i++)
  40a763:	48 83 c0 01          	add    $0x1,%rax
  40a767:	4c 39 f8             	cmp    %r15,%rax
  40a76a:	72 f4                	jb     40a760 <resume_solution+0x470>
            if (num_states > 1)
  40a76c:	49 83 ff 01          	cmp    $0x1,%r15
  40a770:	76 2e                	jbe    40a7a0 <resume_solution+0x4b0>
                switch (local_shuffling_type)
  40a772:	8b 44 24 70          	mov    0x70(%rsp),%eax
  40a776:	83 f8 01             	cmp    $0x1,%eax
  40a779:	0f 84 f1 04 00 00    	je     40ac70 <resume_solution+0x980>
  40a77f:	83 f8 02             	cmp    $0x2,%eax
  40a782:	75 1c                	jne    40a7a0 <resume_solution+0x4b0>
                    if (orig_idx < THE_MOVE_FUNCS_LIST.num)
  40a784:	4c 39 b4 24 e0 00 00 	cmp    %r14,0xe0(%rsp)
  40a78b:	00 
  40a78c:	0f 87 ae 01 00 00    	ja     40a940 <resume_solution+0x650>
  40a792:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a799:	00 00 00 00 
  40a79d:	0f 1f 00             	nopl   (%rax)
            the_soft_dfs_info->current_state_index = 0;
  40a7a0:	48 c7 43 20 00 00 00 	movq   $0x0,0x20(%rbx)
  40a7a7:	00 
  40a7a8:	48 8b 8c 24 00 01 00 	mov    0x100(%rsp),%rcx
  40a7af:	00 
  40a7b0:	48 c7 c2 f8 ff ff ff 	mov    $0xfffffffffffffff8,%rdx
  40a7b7:	48 c7 c0 ff ff ff ff 	mov    $0xffffffffffffffff,%rax
        while (++state_idx < num_states)
  40a7be:	48 89 c6             	mov    %rax,%rsi
                (!is_scan_visited(single_derived_state, soft_thread_id)))
  40a7c1:	4c 63 44 24 24       	movslq 0x24(%rsp),%r8
  40a7c6:	48 f7 de             	neg    %rsi
  40a7c9:	48 8d 14 f2          	lea    (%rdx,%rsi,8),%rdx
  40a7cd:	48 01 d7             	add    %rdx,%rdi
        while (++state_idx < num_states)
  40a7d0:	48 83 c0 01          	add    $0x1,%rax
  40a7d4:	48 39 c8             	cmp    %rcx,%rax
  40a7d7:	0f 83 83 04 00 00    	jae    40ac60 <resume_solution+0x970>
                derived_states[(*(++rand_int_ptr)).idx].state_ptr;
  40a7dd:	48 63 14 c7          	movslq (%rdi,%rax,8),%rdx
            fcs_collectible_state *const single_derived_state =
  40a7e1:	48 8b b4 24 98 00 00 	mov    0x98(%rsp),%rsi
  40a7e8:	00 
  40a7e9:	48 c1 e2 04          	shl    $0x4,%rdx
  40a7ed:	48 8b 14 16          	mov    (%rsi,%rdx,1),%rdx
            if ((!fcs__is_state_a_dead_end(single_derived_state)) &&
  40a7f1:	f6 42 56 04          	testb  $0x4,0x56(%rdx)
  40a7f5:	75 d9                	jne    40a7d0 <resume_solution+0x4e0>
                (!is_scan_visited(single_derived_state, soft_thread_id)))
  40a7f7:	46 0f b6 4c 02 57    	movzbl 0x57(%rdx,%r8,1),%r9d
  40a7fd:	44 89 ce             	mov    %r9d,%esi
            if ((!fcs__is_state_a_dead_end(single_derived_state)) &&
  40a800:	44 85 4c 24 48       	test   %r9d,0x48(%rsp)
  40a805:	75 c9                	jne    40a7d0 <resume_solution+0x4e0>
                BUMP_NUM_CHECKED_STATES();
  40a807:	48 8b bc 24 90 00 00 	mov    0x90(%rsp),%rdi
  40a80e:	00 
  40a80f:	40 0a 74 24 46       	or     0x46(%rsp),%sil
  40a814:	48 83 07 01          	addq   $0x1,(%rdi)
                if (unlikely(++DEPTH() >= by_depth_max_depth))
  40a818:	49 8b 7d 38          	mov    0x38(%r13),%rdi
  40a81c:	42 88 74 02 57       	mov    %sil,0x57(%rdx,%r8,1)
  40a821:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
  40a825:	49 89 4d 38          	mov    %rcx,0x38(%r13)
  40a829:	48 3b 8c 24 a0 00 00 	cmp    0xa0(%rsp),%rcx
  40a830:	00 
  40a831:	0f 8d f9 18 00 00    	jge    40c130 <resume_solution+0x1e40>
                the_soft_dfs_info->current_state_index = state_idx;
  40a837:	48 89 43 20          	mov    %rax,0x20(%rbx)
                FCS_ASSIGN_STATE_KEY();
  40a83b:	49 89 d4             	mov    %rdx,%r12
                the_soft_dfs_info->derived_states_list = derived_list;
  40a83e:	c5 f9 6f bc 24 00 01 	vmovdqa 0x100(%rsp),%xmm7
  40a845:	00 00 
                FCS_ASSIGN_STATE_KEY();
  40a847:	48 8d 42 48          	lea    0x48(%rdx),%rax
                derived_list = the_soft_dfs_info->derived_states_list;
  40a84b:	c5 fa 6f ab b8 00 00 	vmovdqu 0xb8(%rbx),%xmm5
  40a852:	00 
                the_soft_dfs_info->state = PTR_STATE = single_derived_state;
  40a853:	48 89 93 b0 00 00 00 	mov    %rdx,0xb0(%rbx)
                FCS_ASSIGN_STATE_KEY();
  40a85a:	48 89 84 24 b0 00 00 	mov    %rax,0xb0(%rsp)
  40a861:	00 
                if (check_if_limits_exceeded())
  40a862:	48 8b 7c 24 30       	mov    0x30(%rsp),%rdi
                ++the_soft_dfs_info;
  40a867:	48 8d 8b b0 00 00 00 	lea    0xb0(%rbx),%rcx
                if (check_if_limits_exceeded())
  40a86e:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  40a875:	00 
                the_soft_dfs_info->derived_states_list = derived_list;
  40a876:	c5 f8 11 7b 08       	vmovups %xmm7,0x8(%rbx)
                the_soft_dfs_info->move_func_list_idx = 0;
  40a87b:	48 c7 83 c8 00 00 00 	movq   $0x0,0xc8(%rbx)
  40a882:	00 00 00 00 
                the_soft_dfs_info->move_func_idx = 0;
  40a886:	48 c7 83 d8 00 00 00 	movq   $0x0,0xd8(%rbx)
  40a88d:	00 00 00 00 
                the_soft_dfs_info->current_state_index = 0;
  40a891:	48 c7 83 d0 00 00 00 	movq   $0x0,0xd0(%rbx)
  40a898:	00 00 00 00 
                FCS_ASSIGN_STATE_KEY();
  40a89c:	48 89 94 24 b8 00 00 	mov    %rdx,0xb8(%rsp)
  40a8a3:	00 
                derived_list = the_soft_dfs_info->derived_states_list;
  40a8a4:	c5 f8 29 ac 24 00 01 	vmovaps %xmm5,0x100(%rsp)
  40a8ab:	00 00 
                derived_list.num_states = 0;
  40a8ad:	48 c7 84 24 00 01 00 	movq   $0x0,0x100(%rsp)
  40a8b4:	00 00 00 00 00 
                if (check_if_limits_exceeded())
  40a8b9:	48 3b 38             	cmp    (%rax),%rdi
  40a8bc:	0f 84 3e 18 00 00    	je     40c100 <resume_solution+0x1e10>
  40a8c2:	49 8b 45 38          	mov    0x38(%r13),%rax
        the_soft_dfs_info->current_state_index = num_states;
  40a8c6:	48 89 cb             	mov    %rcx,%rbx
        if (unlikely(DEPTH() + 1 >= dfs_max_depth))
  40a8c9:	48 83 c0 01          	add    $0x1,%rax
  40a8cd:	48 3b 44 24 68       	cmp    0x68(%rsp),%rax
  40a8d2:	0f 8c 38 fd ff ff    	jl     40a610 <resume_solution+0x320>
    const_AUTO(new_dfs_max_depth,
  40a8d8:	49 8b 45 28          	mov    0x28(%r13),%rax
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40a8dc:	49 8b 7d 30          	mov    0x30(%r13),%rdi
    const_AUTO(new_dfs_max_depth,
  40a8e0:	48 8d 58 40          	lea    0x40(%rax),%rbx
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40a8e4:	48 69 f3 b0 00 00 00 	imul   $0xb0,%rbx,%rsi
    const_AUTO(new_dfs_max_depth,
  40a8eb:	48 89 5c 24 68       	mov    %rbx,0x68(%rsp)
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40a8f0:	e8 7b 68 ff ff       	callq  401170 <realloc@plt>
    memset(DFS_VAR(soft_thread, soft_dfs_info) +
  40a8f5:	ba 00 2c 00 00       	mov    $0x2c00,%edx
  40a8fa:	31 f6                	xor    %esi,%esi
  40a8fc:	49 69 7d 28 b0 00 00 	imul   $0xb0,0x28(%r13),%rdi
  40a903:	00 
    DFS_VAR(soft_thread, soft_dfs_info) =
  40a904:	49 89 45 30          	mov    %rax,0x30(%r13)
    memset(DFS_VAR(soft_thread, soft_dfs_info) +
  40a908:	48 01 c7             	add    %rax,%rdi
  40a90b:	e8 90 67 ff ff       	callq  4010a0 <memset@plt>
    DFS_VAR(soft_thread, dfs_max_depth) = new_dfs_max_depth;
  40a910:	49 89 5d 28          	mov    %rbx,0x28(%r13)
            the_soft_dfs_info = &(DFS_VAR(soft_thread, soft_dfs_info)[DEPTH()]);
  40a914:	49 69 5d 38 b0 00 00 	imul   $0xb0,0x38(%r13),%rbx
  40a91b:	00 
  40a91c:	49 03 5d 30          	add    0x30(%r13),%rbx
            derived_list = the_soft_dfs_info->derived_states_list;
  40a920:	c5 fa 6f 6b 08       	vmovdqu 0x8(%rbx),%xmm5
  40a925:	c5 f8 29 ac 24 00 01 	vmovaps %xmm5,0x100(%rsp)
  40a92c:	00 00 
  40a92e:	e9 dd fc ff ff       	jmpq   40a610 <resume_solution+0x320>
  40a933:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a93a:	00 00 00 00 
  40a93e:	66 90                	xchg   %ax,%ax
                            rand_array[i].rating = befs_rate_state(soft_thread,
  40a940:	49 8b 45 00          	mov    0x0(%r13),%rax
  40a944:	4d 89 ee             	mov    %r13,%r14
  40a947:	48 89 5c 24 08       	mov    %rbx,0x8(%rsp)
  40a94c:	c5 e9 57 d2          	vxorpd %xmm2,%xmm2,%xmm2
  40a950:	48 89 44 24 28       	mov    %rax,0x28(%rsp)
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40a955:	48 8b 84 24 a8 00 00 	mov    0xa8(%rsp),%rax
  40a95c:	00 
    if (weighting->should_go_over_stacks)
  40a95d:	0f b6 48 18          	movzbl 0x18(%rax),%ecx
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40a961:	c5 fb 10 78 38       	vmovsd 0x38(%rax),%xmm7
    if (num_cards_out_lookup_table[1])
  40a966:	c5 fb 10 70 50       	vmovsd 0x50(%rax),%xmm6
  40a96b:	c5 fb 10 68 40       	vmovsd 0x40(%rax),%xmm5
    if (weighting->should_go_over_stacks)
  40a970:	88 4c 24 45          	mov    %cl,0x45(%rsp)
  40a974:	48 8d 48 48          	lea    0x48(%rax),%rcx
  40a978:	4a 8d 04 fd 00 00 00 	lea    0x0(,%r15,8),%rax
  40a97f:	00 
  40a980:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
  40a985:	45 31 ff             	xor    %r15d,%r15d
  40a988:	48 89 44 24 60       	mov    %rax,0x60(%rsp)
  40a98d:	0f 1f 00             	nopl   (%rax)
                                    calc_depth(derived_states[i].state_ptr));
  40a990:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  40a997:	00 
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40a998:	c5 f9 57 c0          	vxorpd %xmm0,%xmm0,%xmm0
  40a99c:	ba 20 4e 00 00       	mov    $0x4e20,%edx
  40a9a1:	4a 8b 04 78          	mov    (%rax,%r15,2),%rax
  40a9a5:	2b 50 50             	sub    0x50(%rax),%edx
  40a9a8:	78 08                	js     40a9b2 <resume_solution+0x6c2>
  40a9aa:	c5 f9 57 c0          	vxorpd %xmm0,%xmm0,%xmm0
  40a9ae:	c5 fb 2a c2          	vcvtsi2sd %edx,%xmm0,%xmm0
    if (num_cards_out_lookup_table[1])
  40a9b2:	c5 f9 2e f2          	vucomisd %xmm2,%xmm6
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40a9b6:	c5 c3 59 c0          	vmulsd %xmm0,%xmm7,%xmm0
    if (num_cards_out_lookup_table[1])
  40a9ba:	7a 02                	jp     40a9be <resume_solution+0x6ce>
  40a9bc:	74 2d                	je     40a9eb <resume_solution+0x6fb>
            sum += num_cards_out_lookup_table[(
  40a9be:	48 8b 74 24 18       	mov    0x18(%rsp),%rsi
  40a9c3:	48 0f be 50 44       	movsbq 0x44(%rax),%rdx
  40a9c8:	c5 fb 58 04 d6       	vaddsd (%rsi,%rdx,8),%xmm0,%xmm0
  40a9cd:	48 0f be 50 45       	movsbq 0x45(%rax),%rdx
  40a9d2:	c5 fb 58 04 d6       	vaddsd (%rsi,%rdx,8),%xmm0,%xmm0
  40a9d7:	48 0f be 50 46       	movsbq 0x46(%rax),%rdx
  40a9dc:	c5 fb 58 04 d6       	vaddsd (%rsi,%rdx,8),%xmm0,%xmm0
  40a9e1:	48 0f be 50 47       	movsbq 0x47(%rax),%rdx
  40a9e6:	c5 fb 58 04 d6       	vaddsd (%rsi,%rdx,8),%xmm0,%xmm0
    if (weighting->should_go_over_stacks)
  40a9eb:	80 7c 24 45 00       	cmpb   $0x0,0x45(%rsp)
  40a9f0:	0f 84 d6 00 00 00    	je     40aacc <resume_solution+0x7dc>
  40a9f6:	48 8d 48 40          	lea    0x40(%rax),%rcx
  40a9fa:	49 89 c0             	mov    %rax,%r8
    fcs_seq_cards_power_type seqs_over_renegade_cards = 0;
  40a9fd:	c5 e1 57 db          	vxorpd %xmm3,%xmm3,%xmm3
    fcs_seq_cards_power_type cards_under_sequences = 0;
  40aa01:	c4 41 39 57 c0       	vxorpd %xmm8,%xmm8,%xmm8
  40aa06:	48 89 4c 24 10       	mov    %rcx,0x10(%rsp)
    fcs_game_limit num_vacant_stacks = 0;
  40aa0b:	31 c9                	xor    %ecx,%ecx
  40aa0d:	eb 0f                	jmp    40aa1e <resume_solution+0x72e>
  40aa0f:	90                   	nop
                    ++num_vacant_stacks;
  40aa10:	80 d1 00             	adc    $0x0,%cl
  40aa13:	49 83 c0 08          	add    $0x8,%r8
        for (int a = 0; a < LOCAL_STACKS_NUM; ++a)
  40aa17:	4c 3b 44 24 10       	cmp    0x10(%rsp),%r8
  40aa1c:	74 50                	je     40aa6e <resume_solution+0x77e>
            const_AUTO(col, fcs_state_get_col(*state, a));
  40aa1e:	4d 8b 10             	mov    (%r8),%r10
            const int cards_num = fcs_col_len(col);
  40aa21:	41 0f be 32          	movsbl (%r10),%esi
            if (cards_num <= 1)
  40aa25:	83 fe 01             	cmp    $0x1,%esi
  40aa28:	7e e6                	jle    40aa10 <resume_solution+0x720>
            const int c = update_col_cards_under_sequences(
  40aa2a:	8d 56 ff             	lea    -0x1(%rsi),%edx
    fcs_card this_card = fcs_col_get_card(col, d);
  40aa2d:	48 63 d2             	movslq %edx,%rdx
  40aa30:	4d 0f be 4c 12 01    	movsbq 0x1(%r10,%rdx,1),%r9
             prev_card = fcs_col_get_card(col, d - 1);
  40aa36:	4d 0f be 1c 12       	movsbq (%r10,%rdx,1),%r11
  40aa3b:	89 d3                	mov    %edx,%ebx
  40aa3d:	4d 89 dd             	mov    %r11,%r13
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40aa40:	49 c1 e3 06          	shl    $0x6,%r11
    for (; (d > 0) && ({
  40aa44:	43 80 bc 19 c0 05 41 	cmpb   $0x0,0x4105c0(%r9,%r11,1)
  40aa4b:	00 00 
  40aa4d:	0f 84 ed 01 00 00    	je     40ac40 <resume_solution+0x950>
  40aa53:	48 83 ea 01          	sub    $0x1,%rdx
         d--, this_card = prev_card)
  40aa57:	4d 0f be cd          	movsbq %r13b,%r9
    for (; (d > 0) && ({
  40aa5b:	85 d2                	test   %edx,%edx
  40aa5d:	75 d7                	jne    40aa36 <resume_solution+0x746>
            cards_under_sequences += FCS_SEQS_OVER_RENEGADE_POWER(c);
  40aa5f:	c5 3b 58 c2          	vaddsd %xmm2,%xmm8,%xmm8
            if (c > 0)
  40aa63:	49 83 c0 08          	add    $0x8,%r8
        for (int a = 0; a < LOCAL_STACKS_NUM; ++a)
  40aa67:	4c 3b 44 24 10       	cmp    0x10(%rsp),%r8
  40aa6c:	75 b0                	jne    40aa1e <resume_solution+0x72e>
        if (fcs_freecell_is_empty(*state_ptr, i))
  40aa6e:	80 78 40 00          	cmpb   $0x0,0x40(%rax)
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40aa72:	c5 f1 57 c9          	vxorpd %xmm1,%xmm1,%xmm1
  40aa76:	48 8b b4 24 a8 00 00 	mov    0xa8(%rsp),%rsi
  40aa7d:	00 
        if (fcs_freecell_is_empty(*state_ptr, i))
  40aa7e:	0f 94 c2             	sete   %dl
            num_vacant_freecells++;
  40aa81:	80 78 41 01          	cmpb   $0x1,0x41(%rax)
                (seqs_over_renegade_cards *
  40aa85:	c5 e3 59 5e 30       	vmulsd 0x30(%rsi),%xmm3,%xmm3
            num_vacant_freecells++;
  40aa8a:	80 d2 00             	adc    $0x0,%dl
  40aa8d:	80 78 42 01          	cmpb   $0x1,0x42(%rax)
  40aa91:	80 d2 00             	adc    $0x0,%dl
  40aa94:	80 78 43 01          	cmpb   $0x1,0x43(%rax)
  40aa98:	80 d2 00             	adc    $0x0,%dl
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40aa9b:	0f b6 d2             	movzbl %dl,%edx
  40aa9e:	83 c2 01             	add    $0x1,%edx
  40aaa1:	d3 e2                	shl    %cl,%edx
                ((instance->initial_cards_under_sequences_value -
  40aaa3:	48 8b 4c 24 28       	mov    0x28(%rsp),%rcx
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40aaa8:	c5 f3 2a ca          	vcvtsi2sd %edx,%xmm1,%xmm1
  40aaac:	c5 f3 59 4e 20       	vmulsd 0x20(%rsi),%xmm1,%xmm1
                ((instance->initial_cards_under_sequences_value -
  40aab1:	c5 fb 10 61 08       	vmovsd 0x8(%rcx),%xmm4
  40aab6:	c4 c1 5b 5c e0       	vsubsd %xmm8,%xmm4,%xmm4
                     cards_under_sequences) *
  40aabb:	c5 db 59 66 28       	vmulsd 0x28(%rsi),%xmm4,%xmm4
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40aac0:	c5 f3 58 cc          	vaddsd %xmm4,%xmm1,%xmm1
                    weighting->cards_under_sequences_factor) +
  40aac4:	c5 f3 58 cb          	vaddsd %xmm3,%xmm1,%xmm1
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40aac8:	c5 fb 58 c1          	vaddsd %xmm1,%xmm0,%xmm0
    if (num_cards_not_on_parents_weight)
  40aacc:	c5 f9 2e ea          	vucomisd %xmm2,%xmm5
  40aad0:	7a 06                	jp     40aad8 <resume_solution+0x7e8>
  40aad2:	0f 84 dc 00 00 00    	je     40abb4 <resume_solution+0x8c4>
  40aad8:	48 8d 58 40          	lea    0x40(%rax),%rbx
        int num_cards_not_on_parents = (LOCAL_DECKS_NUM * 52);
  40aadc:	b9 34 00 00 00       	mov    $0x34,%ecx
  40aae1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40aae8:	00 00 00 00 
  40aaec:	0f 1f 40 00          	nopl   0x0(%rax)
            const_AUTO(col, fcs_state_get_col(*state, stack_idx));
  40aaf0:	48 8b 30             	mov    (%rax),%rsi
            const uint_fast16_t col_len = fcs_col_len(col);
  40aaf3:	4c 0f be 16          	movsbq (%rsi),%r10
            for (uint_fast16_t h = 1; h < col_len; h++)
  40aaf7:	49 83 fa 01          	cmp    $0x1,%r10
  40aafb:	0f 86 96 00 00 00    	jbe    40ab97 <resume_solution+0x8a7>
  40ab01:	41 80 fa 03          	cmp    $0x3,%r10b
  40ab05:	0f 86 25 01 00 00    	jbe    40ac30 <resume_solution+0x940>
  40ab0b:	4c 0f be 4e 01       	movsbq 0x1(%rsi),%r9
  40ab10:	4d 8d 42 fc          	lea    -0x4(%r10),%r8
  40ab14:	ba 01 00 00 00       	mov    $0x1,%edx
  40ab19:	49 83 e0 fe          	and    $0xfffffffffffffffe,%r8
  40ab1d:	49 83 c0 03          	add    $0x3,%r8
  40ab21:	4c 0f be 5c 16 01    	movsbq 0x1(%rsi,%rdx,1),%r11
  40ab27:	4d 89 dd             	mov    %r11,%r13
  40ab2a:	49 c1 e5 06          	shl    $0x6,%r13
  40ab2e:	4f 8d 8c 0d c0 05 41 	lea    0x4105c0(%r13,%r9,1),%r9
  40ab35:	00 
                    num_cards_not_on_parents--;
  40ab36:	41 80 39 01          	cmpb   $0x1,(%r9)
  40ab3a:	83 d9 00             	sbb    $0x0,%ecx
                if (!fcs_is_parent_card(
  40ab3d:	48 83 c2 02          	add    $0x2,%rdx
  40ab41:	4c 0f be 0c 16       	movsbq (%rsi,%rdx,1),%r9
  40ab46:	4d 89 cd             	mov    %r9,%r13
  40ab49:	49 c1 e5 06          	shl    $0x6,%r13
  40ab4d:	4f 8d 9c 2b c0 05 41 	lea    0x4105c0(%r11,%r13,1),%r11
  40ab54:	00 
                    num_cards_not_on_parents--;
  40ab55:	41 80 3b 01          	cmpb   $0x1,(%r11)
  40ab59:	83 d9 00             	sbb    $0x0,%ecx
  40ab5c:	4c 39 c2             	cmp    %r8,%rdx
  40ab5f:	75 c0                	jne    40ab21 <resume_solution+0x831>
  40ab61:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40ab68:	00 00 00 00 
  40ab6c:	0f 1f 40 00          	nopl   0x0(%rax)
                        fcs_col_get_card(col, h - 1), fcs_col_get_card(col, h)))
  40ab70:	48 83 c2 01          	add    $0x1,%rdx
  40ab74:	4c 0f be 04 16       	movsbq (%rsi,%rdx,1),%r8
  40ab79:	4c 0f be 4c 16 ff    	movsbq -0x1(%rsi,%rdx,1),%r9
  40ab7f:	49 c1 e0 06          	shl    $0x6,%r8
  40ab83:	4f 8d 84 01 c0 05 41 	lea    0x4105c0(%r9,%r8,1),%r8
  40ab8a:	00 
                    num_cards_not_on_parents--;
  40ab8b:	41 80 38 01          	cmpb   $0x1,(%r8)
  40ab8f:	83 d9 00             	sbb    $0x0,%ecx
            for (uint_fast16_t h = 1; h < col_len; h++)
  40ab92:	49 39 d2             	cmp    %rdx,%r10
  40ab95:	77 d9                	ja     40ab70 <resume_solution+0x880>
  40ab97:	48 83 c0 08          	add    $0x8,%rax
        for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  40ab9b:	48 39 c3             	cmp    %rax,%rbx
  40ab9e:	0f 85 4c ff ff ff    	jne    40aaf0 <resume_solution+0x800>
        sum += num_cards_not_on_parents * num_cards_not_on_parents_weight;
  40aba4:	c5 f1 57 c9          	vxorpd %xmm1,%xmm1,%xmm1
  40aba8:	c5 f3 2a c9          	vcvtsi2sd %ecx,%xmm1,%xmm1
  40abac:	c5 f3 59 cd          	vmulsd %xmm5,%xmm1,%xmm1
  40abb0:	c5 fb 58 c1          	vaddsd %xmm1,%xmm0,%xmm0
    return ((int)sum);
  40abb4:	c5 fb 2c c0          	vcvttsd2si %xmm0,%eax
  40abb8:	42 89 44 3f 04       	mov    %eax,0x4(%rdi,%r15,1)
  40abbd:	49 83 c7 08          	add    $0x8,%r15
                        for (size_t i = 0; i < num_states; i++)
  40abc1:	4c 39 7c 24 60       	cmp    %r15,0x60(%rsp)
  40abc6:	0f 85 c4 fd ff ff    	jne    40a990 <resume_solution+0x6a0>
                        const_AUTO(end, rand_array + num_states);
  40abcc:	48 8b 4c 24 60       	mov    0x60(%rsp),%rcx
  40abd1:	4d 89 f5             	mov    %r14,%r13
                        for (var_PTR(p, rand_array + 1); p < end; ++p)
  40abd4:	48 8d 57 08          	lea    0x8(%rdi),%rdx
  40abd8:	48 8b 5c 24 08       	mov    0x8(%rsp),%rbx
                        const_AUTO(end, rand_array + num_states);
  40abdd:	48 01 f9             	add    %rdi,%rcx
                        for (var_PTR(p, rand_array + 1); p < end; ++p)
  40abe0:	48 39 d1             	cmp    %rdx,%rcx
  40abe3:	0f 86 b7 fb ff ff    	jbe    40a7a0 <resume_solution+0x4b0>
  40abe9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
                                   move->rating < move[-1].rating)
  40abf0:	8b 72 04             	mov    0x4(%rdx),%esi
                            while (move > rand_array &&
  40abf3:	39 72 fc             	cmp    %esi,-0x4(%rdx)
  40abf6:	7e 28                	jle    40ac20 <resume_solution+0x930>
  40abf8:	48 89 d0             	mov    %rdx,%rax
  40abfb:	eb 08                	jmp    40ac05 <resume_solution+0x915>
  40abfd:	0f 1f 00             	nopl   (%rax)
  40ac00:	39 70 fc             	cmp    %esi,-0x4(%rax)
  40ac03:	7e 1b                	jle    40ac20 <resume_solution+0x930>
                                *move = move[-1];
  40ac05:	4c 8b 48 f8          	mov    -0x8(%rax),%r9
                                *(--move) = temp;
  40ac09:	48 83 e8 08          	sub    $0x8,%rax
                                const_AUTO(temp, *move);
  40ac0d:	44 8b 40 08          	mov    0x8(%rax),%r8d
                                *move = move[-1];
  40ac11:	4c 89 48 08          	mov    %r9,0x8(%rax)
                                *(--move) = temp;
  40ac15:	44 89 00             	mov    %r8d,(%rax)
  40ac18:	89 70 04             	mov    %esi,0x4(%rax)
                            while (move > rand_array &&
  40ac1b:	48 39 c7             	cmp    %rax,%rdi
  40ac1e:	72 e0                	jb     40ac00 <resume_solution+0x910>
                        for (var_PTR(p, rand_array + 1); p < end; ++p)
  40ac20:	48 83 c2 08          	add    $0x8,%rdx
  40ac24:	48 39 d1             	cmp    %rdx,%rcx
  40ac27:	77 c7                	ja     40abf0 <resume_solution+0x900>
  40ac29:	e9 72 fb ff ff       	jmpq   40a7a0 <resume_solution+0x4b0>
  40ac2e:	66 90                	xchg   %ax,%ax
            for (uint_fast16_t h = 1; h < col_len; h++)
  40ac30:	ba 01 00 00 00       	mov    $0x1,%edx
  40ac35:	e9 36 ff ff ff       	jmpq   40ab70 <resume_solution+0x880>
  40ac3a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                            : FCS_SEQS_OVER_RENEGADE_POWER(cards_num - c));
  40ac40:	29 de                	sub    %ebx,%esi
            cards_under_sequences += FCS_SEQS_OVER_RENEGADE_POWER(c);
  40ac42:	48 63 d2             	movslq %edx,%rdx
  40ac45:	c5 3b 58 04 d5 a0 fd 	vaddsd 0x40fda0(,%rdx,8),%xmm8,%xmm8
  40ac4c:	40 00 
                            : FCS_SEQS_OVER_RENEGADE_POWER(cards_num - c));
  40ac4e:	48 63 f6             	movslq %esi,%rsi
                seqs_over_renegade_cards +=
  40ac51:	c5 e3 58 1c f5 a0 fd 	vaddsd 0x40fda0(,%rsi,8),%xmm3,%xmm3
  40ac58:	40 00 
  40ac5a:	e9 b4 fd ff ff       	jmpq   40aa13 <resume_solution+0x723>
  40ac5f:	90                   	nop
        the_soft_dfs_info->current_state_index = num_states;
  40ac60:	48 89 4b 20          	mov    %rcx,0x20(%rbx)
  40ac64:	48 89 d9             	mov    %rbx,%rcx
  40ac67:	49 8b 45 38          	mov    0x38(%r13),%rax
  40ac6b:	e9 56 fc ff ff       	jmpq   40a8c6 <resume_solution+0x5d6>
                    for (size_t i = num_states - 1; i > 0; i--)
  40ac70:	49 8b 4d 40          	mov    0x40(%r13),%rcx
  40ac74:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40ac7b:	00 00 00 00 
  40ac7f:	90                   	nop
    *my_rand = (long)seed;
}

static inline int fc_solve_rand_rand15(fcs_rand_gen *const my_rand)
{
    return ((((*my_rand) = ((*my_rand) * 214013 + 2531011)) >> 16) & 0x7fff);
  40ac80:	48 69 c9 fd 43 03 00 	imul   $0x343fd,%rcx,%rcx
                        const_AUTO(swap_save, rand_array[i]);
  40ac87:	46 8b 44 ff f8       	mov    -0x8(%rdi,%r15,8),%r8d
  40ac8c:	42 8b 74 ff fc       	mov    -0x4(%rdi,%r15,8),%esi
  40ac91:	48 8d 91 c3 9e 26 00 	lea    0x269ec3(%rcx),%rdx
  40ac98:	48 69 ca fd 43 03 00 	imul   $0x343fd,%rdx,%rcx
  40ac9f:	48 c1 fa 10          	sar    $0x10,%rdx
  40aca3:	81 e2 ff 7f 00 00    	and    $0x7fff,%edx
  40aca9:	48 81 c1 c3 9e 26 00 	add    $0x269ec3,%rcx
  40acb0:	48 89 c8             	mov    %rcx,%rax
  40acb3:	49 89 4d 40          	mov    %rcx,0x40(%r13)
  40acb7:	48 c1 f8 10          	sar    $0x10,%rax
// This function constructs a larger integral number of out of two
// 15-bit ones.
static inline int fc_solve_rand_get_random_number(fcs_rand_gen *const my_rand)
{
    const int first = fc_solve_rand_rand15(my_rand);
    return (first | (fc_solve_rand_rand15(my_rand) << 15));
  40acbb:	c1 e0 0f             	shl    $0xf,%eax
  40acbe:	25 00 80 ff 3f       	and    $0x3fff8000,%eax
  40acc3:	09 d0                	or     %edx,%eax
                        const typeof(i) j =
  40acc5:	31 d2                	xor    %edx,%edx
                            (fc_solve_rand_get_random_number(rand_gen) %
  40acc7:	48 98                	cltq   
                        const typeof(i) j =
  40acc9:	49 f7 f7             	div    %r15
                        rand_array[i] = rand_array[j];
  40accc:	48 8d 04 d7          	lea    (%rdi,%rdx,8),%rax
  40acd0:	48 8b 10             	mov    (%rax),%rdx
  40acd3:	4a 89 54 ff f8       	mov    %rdx,-0x8(%rdi,%r15,8)
                        rand_array[j] = swap_save;
  40acd8:	49 83 ef 01          	sub    $0x1,%r15
  40acdc:	44 89 00             	mov    %r8d,(%rax)
  40acdf:	89 70 04             	mov    %esi,0x4(%rax)
                    for (size_t i = num_states - 1; i > 0; i--)
  40ace2:	49 83 ff 01          	cmp    $0x1,%r15
  40ace6:	75 98                	jne    40ac80 <resume_solution+0x990>
  40ace8:	e9 b3 fa ff ff       	jmpq   40a7a0 <resume_solution+0x4b0>
  40aced:	0f 1f 00             	nopl   (%rax)
                local_shuffling_type =
  40acf0:	48 8b 84 24 a8 00 00 	mov    0xa8(%rsp),%rax
  40acf7:	00 
  40acf8:	4c 89 f2             	mov    %r14,%rdx
  40acfb:	8b 40 10             	mov    0x10(%rax),%eax
  40acfe:	89 c1                	mov    %eax,%ecx
  40ad00:	89 44 24 70          	mov    %eax,0x70(%rsp)
  40ad04:	48 8b 43 28          	mov    0x28(%rbx),%rax
  40ad08:	85 c9                	test   %ecx,%ecx
  40ad0a:	48 8d 8c 24 00 01 00 	lea    0x100(%rsp),%rcx
  40ad11:	00 
  40ad12:	48 89 8c 24 98 00 00 	mov    %rcx,0x98(%rsp)
  40ad19:	00 
  40ad1a:	0f 85 90 00 00 00    	jne    40adb0 <resume_solution+0xac0>
                        .move_funcs[the_soft_dfs_info->move_func_idx]
  40ad20:	48 69 d2 e8 00 00 00 	imul   $0xe8,%rdx,%rdx
                        .f(soft_thread, pass, &derived_list);
  40ad27:	4c 8b bc 24 c0 00 00 	mov    0xc0(%rsp),%r15
  40ad2e:	00 
                    THE_MOVE_FUNCS_LIST
  40ad2f:	4c 89 ef             	mov    %r13,%rdi
  40ad32:	48 8b 8c 24 98 00 00 	mov    0x98(%rsp),%rcx
  40ad39:	00 
  40ad3a:	48 8b b4 24 b8 00 00 	mov    0xb8(%rsp),%rsi
  40ad41:	00 
                        .f(soft_thread, pass, &derived_list);
  40ad42:	4d 8b 04 17          	mov    (%r15,%rdx,1),%r8
                    THE_MOVE_FUNCS_LIST
  40ad46:	48 8b 94 24 b0 00 00 	mov    0xb0(%rsp),%rdx
  40ad4d:	00 
  40ad4e:	41 ff 14 c0          	callq  *(%r8,%rax,8)
                            .groups[the_soft_dfs_info->move_func_list_idx]
  40ad52:	48 8b 53 18          	mov    0x18(%rbx),%rdx
                    if ((++the_soft_dfs_info->move_func_idx) ==
  40ad56:	48 8b 43 28          	mov    0x28(%rbx),%rax
                            .num)
  40ad5a:	48 69 ca e8 00 00 00 	imul   $0xe8,%rdx,%rcx
                    if ((++the_soft_dfs_info->move_func_idx) ==
  40ad61:	48 83 c0 01          	add    $0x1,%rax
  40ad65:	48 89 43 28          	mov    %rax,0x28(%rbx)
  40ad69:	49 39 44 0f 08       	cmp    %rax,0x8(%r15,%rcx,1)
  40ad6e:	0f 84 8c 00 00 00    	je     40ae00 <resume_solution+0xb10>
                         (derived_list.num_states == 0));
  40ad74:	4c 8b bc 24 00 01 00 	mov    0x100(%rsp),%r15
  40ad7b:	00 
                } while ((local_shuffling_type != FCS_NO_SHUFFLING) ||
  40ad7c:	4d 85 ff             	test   %r15,%r15
  40ad7f:	74 9f                	je     40ad20 <resume_solution+0xa30>
            if (num_states >
  40ad81:	48 8b 7b 38          	mov    0x38(%rbx),%rdi
  40ad85:	4c 39 7b 30          	cmp    %r15,0x30(%rbx)
  40ad89:	0f 82 9c f9 ff ff    	jb     40a72b <resume_solution+0x43b>
            for (size_t i = 0; i < num_states; i++)
  40ad8f:	48 8b 84 24 08 01 00 	mov    0x108(%rsp),%rax
  40ad96:	00 
  40ad97:	48 89 84 24 98 00 00 	mov    %rax,0x98(%rsp)
  40ad9e:	00 
  40ad9f:	e9 b4 f9 ff ff       	jmpq   40a758 <resume_solution+0x468>
  40ada4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40adab:	00 00 00 00 
  40adaf:	90                   	nop
                        .move_funcs[the_soft_dfs_info->move_func_idx]
  40adb0:	48 69 d2 e8 00 00 00 	imul   $0xe8,%rdx,%rdx
                        .f(soft_thread, pass, &derived_list);
  40adb7:	4c 8b bc 24 c0 00 00 	mov    0xc0(%rsp),%r15
  40adbe:	00 
                    THE_MOVE_FUNCS_LIST
  40adbf:	4c 89 ef             	mov    %r13,%rdi
  40adc2:	48 8b 8c 24 98 00 00 	mov    0x98(%rsp),%rcx
  40adc9:	00 
  40adca:	48 8b b4 24 b8 00 00 	mov    0xb8(%rsp),%rsi
  40add1:	00 
                        .f(soft_thread, pass, &derived_list);
  40add2:	4d 8b 04 17          	mov    (%r15,%rdx,1),%r8
                    THE_MOVE_FUNCS_LIST
  40add6:	48 8b 94 24 b0 00 00 	mov    0xb0(%rsp),%rdx
  40addd:	00 
  40adde:	41 ff 14 c0          	callq  *(%r8,%rax,8)
                            .groups[the_soft_dfs_info->move_func_list_idx]
  40ade2:	48 8b 53 18          	mov    0x18(%rbx),%rdx
                    if ((++the_soft_dfs_info->move_func_idx) ==
  40ade6:	48 8b 43 28          	mov    0x28(%rbx),%rax
                            .num)
  40adea:	48 69 ca e8 00 00 00 	imul   $0xe8,%rdx,%rcx
                    if ((++the_soft_dfs_info->move_func_idx) ==
  40adf1:	48 83 c0 01          	add    $0x1,%rax
  40adf5:	48 89 43 28          	mov    %rax,0x28(%rbx)
  40adf9:	49 3b 44 0f 08       	cmp    0x8(%r15,%rcx,1),%rax
  40adfe:	75 b0                	jne    40adb0 <resume_solution+0xac0>
                        the_soft_dfs_info->move_func_list_idx++;
  40ae00:	48 83 c2 01          	add    $0x1,%rdx
                        the_soft_dfs_info->move_func_idx = 0;
  40ae04:	48 c7 43 28 00 00 00 	movq   $0x0,0x28(%rbx)
  40ae0b:	00 
                        the_soft_dfs_info->move_func_list_idx++;
  40ae0c:	48 89 53 18          	mov    %rdx,0x18(%rbx)
                        break;
  40ae10:	e9 04 f9 ff ff       	jmpq   40a719 <resume_solution+0x429>
  40ae15:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40ae1c:	00 00 00 00 
  40ae20:	88 44 24 60          	mov    %al,0x60(%rsp)
    const bool is_a_complete_scan =
  40ae24:	41 0f b6 87 e2 01 00 	movzbl 0x1e2(%r15),%eax
  40ae2b:	00 
    PTR_STATE = BEFS_M_VAR(soft_thread, first_state_to_check);
  40ae2c:	4d 8b b7 d8 01 00 00 	mov    0x1d8(%r15),%r14
    const_AUTO(soft_thread_id, soft_thread->id);
  40ae33:	41 8b 4f 08          	mov    0x8(%r15),%ecx
    fcs_derived_states_list derived = {.num_states = 0, .states = NULL};
  40ae37:	48 c7 84 24 00 01 00 	movq   $0x0,0x100(%rsp)
  40ae3e:	00 00 00 00 00 
  40ae43:	48 c7 84 24 08 01 00 	movq   $0x0,0x108(%rsp)
  40ae4a:	00 00 00 00 00 
    const bool is_a_complete_scan =
  40ae4f:	88 84 24 a0 00 00 00 	mov    %al,0xa0(%rsp)
    const fcs_move_func *const moves_list = BEFS_M_VAR(soft_thread, moves_list);
  40ae56:	49 8b 87 c8 00 00 00 	mov    0xc8(%r15),%rax
    FCS_ASSIGN_STATE_KEY();
  40ae5d:	c4 c1 f9 6e f6       	vmovq  %r14,%xmm6
    const fcs_move_func *const moves_list = BEFS_M_VAR(soft_thread, moves_list);
  40ae62:	48 89 44 24 48       	mov    %rax,0x48(%rsp)
    const fcs_move_func *const moves_list_end =
  40ae67:	49 8b 87 d0 00 00 00 	mov    0xd0(%r15),%rax
  40ae6e:	48 89 84 24 98 00 00 	mov    %rax,0x98(%rsp)
  40ae75:	00 
    FCS_ASSIGN_STATE_KEY();
  40ae76:	49 8d 46 48          	lea    0x48(%r14),%rax
  40ae7a:	c4 e3 c9 22 e8 01    	vpinsrq $0x1,%rax,%xmm6,%xmm5
    const bool enable_pruning = soft_thread->enable_pruning;
  40ae80:	41 0f b6 87 f0 01 00 	movzbl 0x1f0(%r15),%eax
  40ae87:	00 
    FCS_ASSIGN_STATE_KEY();
  40ae88:	c5 f8 29 ac 24 d0 00 	vmovaps %xmm5,0xd0(%rsp)
  40ae8f:	00 00 
    const bool enable_pruning = soft_thread->enable_pruning;
  40ae91:	88 44 24 47          	mov    %al,0x47(%rsp)
    const_SLOT(is_befs, soft_thread);
  40ae95:	41 0f b6 87 f2 01 00 	movzbl 0x1f2(%r15),%eax
  40ae9c:	00 
  40ae9d:	88 84 24 b8 00 00 00 	mov    %al,0xb8(%rsp)
    if (is_befs)
  40aea4:	84 c0                	test   %al,%al
  40aea6:	0f 84 f4 0b 00 00    	je     40baa0 <resume_solution+0x17b0>
        pqueue = &(BEFS_VAR(soft_thread, pqueue));
  40aeac:	49 8d 87 f0 00 00 00 	lea    0xf0(%r15),%rax
  40aeb3:	48 89 84 24 c8 00 00 	mov    %rax,0xc8(%rsp)
  40aeba:	00 
    const_AUTO(max_num_states, calc_ht_max_num_states(instance, hard_thread));
  40aebb:	49 8b 84 24 c8 00 00 	mov    0xc8(%r12),%rax
  40aec2:	00 
  40aec3:	48 89 84 24 b0 00 00 	mov    %rax,0xb0(%rsp)
  40aeca:	00 
    int8_t *const befs_positions_by_rank =
  40aecb:	49 8d 47 60          	lea    0x60(%r15),%rax
  40aecf:	48 89 84 24 c0 00 00 	mov    %rax,0xc0(%rsp)
  40aed6:	00 
    while (PTR_STATE != NULL)
  40aed7:	4d 85 f6             	test   %r14,%r14
  40aeda:	0f 84 41 01 00 00    	je     40b021 <resume_solution+0xd31>
    fcs_states_linked_list_item *queue_last_item = NULL;
  40aee0:	48 c7 84 24 e0 00 00 	movq   $0x0,0xe0(%rsp)
  40aee7:	00 00 00 00 00 
    fcs_states_linked_list_item *queue = NULL;
  40aeec:	48 c7 84 24 a8 00 00 	movq   $0x0,0xa8(%rsp)
  40aef3:	00 00 00 00 00 
                        (is_scan_visited(PTR_STATE, soft_thread_id))))
  40aef8:	89 c8                	mov    %ecx,%eax
  40aefa:	83 e1 07             	and    $0x7,%ecx
  40aefd:	41 0f b6 56 56       	movzbl 0x56(%r14),%edx
  40af02:	c1 f8 03             	sar    $0x3,%eax
  40af05:	89 44 24 40          	mov    %eax,0x40(%rsp)
  40af09:	b8 01 00 00 00       	mov    $0x1,%eax
  40af0e:	d3 e0                	shl    %cl,%eax
    return (enable_pruning && fcs__should_state_be_pruned__state(ptr_state));
  40af10:	80 7c 24 47 00       	cmpb   $0x0,0x47(%rsp)
  40af15:	89 44 24 68          	mov    %eax,0x68(%rsp)
    (FCS_S_SCAN_VISITED(ptr_state))[scan_id >> FCS_CHAR_BIT_SIZE_LOG2] |=
  40af19:	88 84 24 80 00 00 00 	mov    %al,0x80(%rsp)
  40af20:	74 53                	je     40af75 <resume_solution+0xc85>
  40af22:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40af29:	00 00 00 00 
  40af2d:	0f 1f 00             	nopl   (%rax)
  40af30:	f6 c2 10             	test   $0x10,%dl
  40af33:	75 40                	jne    40af75 <resume_solution+0xc85>
                fc_solve_sfs_raymond_prune(soft_thread, pass);
  40af35:	48 8b b4 24 d0 00 00 	mov    0xd0(%rsp),%rsi
  40af3c:	00 
  40af3d:	4c 89 ff             	mov    %r15,%rdi
  40af40:	48 8b 94 24 d8 00 00 	mov    0xd8(%rsp),%rdx
  40af47:	00 
  40af48:	e8 f3 77 ff ff       	callq  402740 <fc_solve_sfs_raymond_prune>
            if (after_pruning_state)
  40af4d:	48 85 c0             	test   %rax,%rax
  40af50:	0f 84 aa 0b 00 00    	je     40bb00 <resume_solution+0x1810>
                ASSIGN_ptr_state(after_pruning_state);
  40af56:	48 8d 50 48          	lea    0x48(%rax),%rdx
  40af5a:	c4 e1 f9 6e e0       	vmovq  %rax,%xmm4
  40af5f:	49 89 c6             	mov    %rax,%r14
  40af62:	c4 e3 d9 22 f2 01    	vpinsrq $0x1,%rdx,%xmm4,%xmm6
  40af68:	0f b6 50 56          	movzbl 0x56(%rax),%edx
  40af6c:	c5 f8 29 b4 24 d0 00 	vmovaps %xmm6,0xd0(%rsp)
  40af73:	00 00 
            if (
  40af75:	83 e2 04             	and    $0x4,%edx
  40af78:	75 1a                	jne    40af94 <resume_solution+0xca4>
                        (is_scan_visited(PTR_STATE, soft_thread_id))))
  40af7a:	48 63 44 24 40       	movslq 0x40(%rsp),%rax
  40af7f:	48 89 44 24 70       	mov    %rax,0x70(%rsp)
  40af84:	41 0f b6 5c 06 57    	movzbl 0x57(%r14,%rax,1),%ebx
                    ((temp_visited & FCS_VISITED_DEAD_END) ||
  40af8a:	23 5c 24 68          	and    0x68(%rsp),%ebx
  40af8e:	0f 84 7c 01 00 00    	je     40b110 <resume_solution+0xe20>
            if (is_befs)
  40af94:	80 bc 24 b8 00 00 00 	cmpb   $0x0,0xb8(%rsp)
  40af9b:	00 
  40af9c:	0f 85 9e 07 00 00    	jne    40b740 <resume_solution+0x1450>
                const_AUTO(save_item, queue->next);
  40afa2:	48 8b 8c 24 a8 00 00 	mov    0xa8(%rsp),%rcx
  40afa9:	00 
  40afaa:	48 8b 41 08          	mov    0x8(%rcx),%rax
                if (save_item != queue_last_item)
  40afae:	48 3b 84 24 e0 00 00 	cmp    0xe0(%rsp),%rax
  40afb5:	00 
  40afb6:	0f 84 34 09 00 00    	je     40b8f0 <resume_solution+0x1600>
                    queue->next = save_item->next;
  40afbc:	48 8b 50 08          	mov    0x8(%rax),%rdx
                    new_ptr_state = save_item->s;
  40afc0:	4c 8b 30             	mov    (%rax),%r14
                    queue->next = save_item->next;
  40afc3:	48 89 51 08          	mov    %rdx,0x8(%rcx)
                    save_item->next = my_brfs_recycle_bin;
  40afc7:	49 8b 97 e8 00 00 00 	mov    0xe8(%r15),%rdx
  40afce:	48 89 50 08          	mov    %rdx,0x8(%rax)
                    my_brfs_recycle_bin = save_item;
  40afd2:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
            ASSIGN_ptr_state(new_ptr_state);
  40afd9:	4d 85 f6             	test   %r14,%r14
  40afdc:	0f 84 5e 09 00 00    	je     40b940 <resume_solution+0x1650>
  40afe2:	80 7c 24 47 00       	cmpb   $0x0,0x47(%rsp)
  40afe7:	49 8d 46 48          	lea    0x48(%r14),%rax
  40afeb:	c4 c1 f9 6e f6       	vmovq  %r14,%xmm6
  40aff0:	c4 e3 c9 22 d0 01    	vpinsrq $0x1,%rax,%xmm6,%xmm2
  40aff6:	41 0f b6 56 56       	movzbl 0x56(%r14),%edx
  40affb:	c5 f8 29 94 24 d0 00 	vmovaps %xmm2,0xd0(%rsp)
  40b002:	00 00 
  40b004:	0f 84 6b ff ff ff    	je     40af75 <resume_solution+0xc85>
  40b00a:	e9 21 ff ff ff       	jmpq   40af30 <resume_solution+0xc40>
  40b00f:	90                   	nop
    if (derived.states != NULL)
  40b010:	48 8b bc 24 08 01 00 	mov    0x108(%rsp),%rdi
  40b017:	00 
  40b018:	48 85 ff             	test   %rdi,%rdi
  40b01b:	0f 85 e0 08 00 00    	jne    40b901 <resume_solution+0x1611>
  40b021:	bb 01 00 00 00       	mov    $0x1,%ebx
    error_code = FCS_STATE_IS_NOT_SOLVEABLE;
  40b026:	41 bd 01 00 00 00    	mov    $0x1,%r13d
  40b02c:	0f 1f 40 00          	nopl   0x0(%rax)
        if (NUM_CHECKED_STATES >=
  40b030:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40b037:	00 
  40b038:	48 8b 30             	mov    (%rax),%rsi
  40b03b:	48 3b b0 c8 00 00 00 	cmp    0xc8(%rax),%rsi
  40b042:	0f 8d a8 09 00 00    	jge    40b9f0 <resume_solution+0x1700>
        if (ret == FCS_STATE_IS_NOT_SOLVEABLE)
  40b048:	83 fb 01             	cmp    $0x1,%ebx
  40b04b:	0f 84 2f 09 00 00    	je     40b980 <resume_solution+0x1690>
        if (was_solved || instance__check_exceeded_stats(instance))
  40b051:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40b058:	00 
  40b059:	45 85 ed             	test   %r13d,%r13d
  40b05c:	74 32                	je     40b090 <resume_solution+0xda0>
  40b05e:	48 63 88 28 05 00 00 	movslq 0x528(%rax),%rcx
    while (HT_FIELD(hard_thread, num_soft_threads_finished) < num_soft_threads)
  40b065:	48 39 8c 24 88 00 00 	cmp    %rcx,0x88(%rsp)
  40b06c:	00 
  40b06d:	0f 8f 1b f4 ff ff    	jg     40a48e <resume_solution+0x19e>
                if ((ret == FCS_STATE_IS_NOT_SOLVEABLE) ||
  40b073:	41 83 fd 01          	cmp    $0x1,%r13d
  40b077:	0f 85 a3 f3 ff ff    	jne    40a420 <resume_solution+0x130>
  40b07d:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40b084:	00 
  40b085:	48 8b 30             	mov    (%rax),%rsi
  40b088:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40b08f:	00 
  40b090:	48 8b 80 40 05 00 00 	mov    0x540(%rax),%rax
        if (instance->num_hard_threads_finished == NUM_HARD_THREADS())
  40b097:	48 83 f8 01          	cmp    $0x1,%rax
  40b09b:	0f 84 76 1f 00 00    	je     40d017 <resume_solution+0x2d27>
            ret = user->ret_code = flare->ret_code = resume_instance(instance);
  40b0a1:	48 8b 8c 24 e8 00 00 	mov    0xe8(%rsp),%rcx
  40b0a8:	00 
        const_AUTO(delta, flare->obj_stats.num_checked_states -
  40b0a9:	48 89 f0             	mov    %rsi,%rax
            ret = user->ret_code = flare->ret_code = resume_instance(instance);
  40b0ac:	44 89 a9 b8 05 00 00 	mov    %r13d,0x5b8(%rcx)
        const_AUTO(delta, flare->obj_stats.num_checked_states -
  40b0b3:	48 2b 81 d0 05 00 00 	sub    0x5d0(%rcx),%rax
            ret = user->ret_code = flare->ret_code = resume_instance(instance);
  40b0ba:	44 89 a9 38 06 00 00 	mov    %r13d,0x638(%rcx)
        user->iterations_board_started_at.num_checked_states += delta;
  40b0c1:	48 01 81 c8 05 00 00 	add    %rax,0x5c8(%rcx)
            flare->instance_is_ready = FALSE;
  40b0c8:	c6 81 bc 05 00 00 00 	movb   $0x0,0x5bc(%rcx)
        flare->obj_stats.num_checked_states = instance->i__num_checked_states;
  40b0cf:	48 89 b1 c0 05 00 00 	mov    %rsi,0x5c0(%rcx)
        user->init_num_checked_states = flare->obj_stats;
  40b0d6:	48 89 b1 d0 05 00 00 	mov    %rsi,0x5d0(%rcx)
        if (user->ret_code == FCS_STATE_WAS_SOLVED)
  40b0dd:	45 85 ed             	test   %r13d,%r13d
  40b0e0:	0f 85 7a 22 00 00    	jne    40d360 <resume_solution+0x3070>
            user->init_num_checked_states = flare->obj_stats;
  40b0e6:	48 8b bc 24 e8 00 00 	mov    0xe8(%rsp),%rdi
  40b0ed:	00 
            ret = user->ret_code = FCS_STATE_WAS_SOLVED;
  40b0ee:	45 31 ed             	xor    %r13d,%r13d
            user->init_num_checked_states = flare->obj_stats;
  40b0f1:	48 8b 87 c0 05 00 00 	mov    0x5c0(%rdi),%rax
            ret = user->ret_code = FCS_STATE_WAS_SOLVED;
  40b0f8:	c7 87 38 06 00 00 00 	movl   $0x0,0x638(%rdi)
  40b0ff:	00 00 00 
            user->init_num_checked_states = flare->obj_stats;
  40b102:	48 89 87 d0 05 00 00 	mov    %rax,0x5d0(%rdi)
            break;
  40b109:	e9 e7 f2 ff ff       	jmpq   40a3f5 <resume_solution+0x105>
  40b10e:	66 90                	xchg   %ax,%ax
        if (check_if_limits_exceeded())
  40b110:	49 8b 0c 24          	mov    (%r12),%rcx
  40b114:	48 39 8c 24 b0 00 00 	cmp    %rcx,0xb0(%rsp)
  40b11b:	00 
  40b11c:	0f 84 fe 12 00 00    	je     40c420 <resume_solution+0x2130>
        if (fcs_freecell_is_empty(*state_ptr, i))
  40b122:	41 80 7e 40 00       	cmpb   $0x0,0x40(%r14)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b127:	49 8b 06             	mov    (%r14),%rax
  40b12a:	49 8b 76 08          	mov    0x8(%r14),%rsi
        if (fcs_freecell_is_empty(*state_ptr, i))
  40b12e:	0f 94 c2             	sete   %dl
            num_vacant_freecells++;
  40b131:	41 80 7e 41 01       	cmpb   $0x1,0x41(%r14)
  40b136:	80 d2 00             	adc    $0x0,%dl
  40b139:	41 80 7e 42 01       	cmpb   $0x1,0x42(%r14)
  40b13e:	80 d2 00             	adc    $0x0,%dl
  40b141:	41 80 7e 43 01       	cmpb   $0x1,0x43(%r14)
  40b146:	80 d2 00             	adc    $0x0,%dl
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b149:	80 38 00             	cmpb   $0x0,(%rax)
  40b14c:	0f 94 c0             	sete   %al
            ++num_vacant_stacks;
  40b14f:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b152:	49 8b 76 10          	mov    0x10(%r14),%rsi
            ++num_vacant_stacks;
  40b156:	14 00                	adc    $0x0,%al
  40b158:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b15b:	49 8b 76 18          	mov    0x18(%r14),%rsi
            ++num_vacant_stacks;
  40b15f:	14 00                	adc    $0x0,%al
  40b161:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b164:	49 8b 76 20          	mov    0x20(%r14),%rsi
            ++num_vacant_stacks;
  40b168:	14 00                	adc    $0x0,%al
  40b16a:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b16d:	49 8b 76 28          	mov    0x28(%r14),%rsi
            ++num_vacant_stacks;
  40b171:	14 00                	adc    $0x0,%al
  40b173:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b176:	49 8b 76 30          	mov    0x30(%r14),%rsi
            ++num_vacant_stacks;
  40b17a:	14 00                	adc    $0x0,%al
  40b17c:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b17f:	49 8b 76 38          	mov    0x38(%r14),%rsi
            ++num_vacant_stacks;
  40b183:	14 00                	adc    $0x0,%al
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b185:	80 3e 00             	cmpb   $0x0,(%rsi)
  40b188:	75 10                	jne    40b19a <resume_solution+0xeaa>
            ++num_vacant_stacks;
  40b18a:	83 c0 01             	add    $0x1,%eax
        if ((num_vacant_stacks == LOCAL_STACKS_NUM) &&
  40b18d:	3c 08                	cmp    $0x8,%al
  40b18f:	75 09                	jne    40b19a <resume_solution+0xeaa>
  40b191:	80 fa 04             	cmp    $0x4,%dl
  40b194:	0f 84 a6 12 00 00    	je     40c440 <resume_solution+0x2150>
        soft_thread->num_vacant_stacks = num_vacant_stacks;
  40b19a:	41 88 87 e3 01 00 00 	mov    %al,0x1e3(%r15)
    memset(positions_by_rank, -1, sizeof(fcs__positions_by_rank));
  40b1a1:	48 8b 84 24 c0 00 00 	mov    0xc0(%rsp),%rax
  40b1a8:	00 
  40b1a9:	c5 f9 76 c0          	vpcmpeqd %xmm0,%xmm0,%xmm0
        soft_thread->num_vacant_freecells = num_vacant_freecells;
  40b1ad:	41 88 97 e4 01 00 00 	mov    %dl,0x1e4(%r15)
  40b1b4:	31 d2                	xor    %edx,%edx
  40b1b6:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  40b1ba:	c5 f8 11 40 10       	vmovups %xmm0,0x10(%rax)
  40b1bf:	c5 f8 11 40 20       	vmovups %xmm0,0x20(%rax)
  40b1c4:	c5 f8 11 40 30       	vmovups %xmm0,0x30(%rax)
  40b1c9:	c5 f8 11 40 40       	vmovups %xmm0,0x40(%rax)
  40b1ce:	c5 f8 11 40 50       	vmovups %xmm0,0x50(%rax)
  40b1d3:	48 c7 40 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rax)
  40b1da:	ff 
            const_AUTO(dest_col, fcs_state_get_col(state_key, ds));
  40b1db:	4d 8b 04 d6          	mov    (%r14,%rdx,8),%r8
            int top_card_idx = fcs_col_len(dest_col);
  40b1df:	41 0f be 00          	movsbl (%r8),%eax
            if (unlikely((top_card_idx--) == 0))
  40b1e3:	8d 48 ff             	lea    -0x1(%rax),%ecx
  40b1e6:	85 c0                	test   %eax,%eax
  40b1e8:	74 67                	je     40b251 <resume_solution+0xf61>
                dest_card = fcs_col_get_card(dest_col, 0);
  40b1ea:	41 0f be 40 01       	movsbl 0x1(%r8),%eax
                for (int dc = 0; dc < top_card_idx;
  40b1ef:	89 d6                	mov    %edx,%esi
  40b1f1:	85 c9                	test   %ecx,%ecx
  40b1f3:	7e 48                	jle    40b23d <resume_solution+0xf4d>
  40b1f5:	31 ff                	xor    %edi,%edi
  40b1f7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40b1fe:	00 00 
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40b200:	4d 0f be 5c 38 02    	movsbq 0x2(%r8,%rdi,1),%r11
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40b206:	4c 0f be c8          	movsbq %al,%r9
  40b20a:	49 c1 e1 06          	shl    $0x6,%r9
                    if (!fcs_is_parent_card(dest_below_card, dest_card))
  40b20e:	43 80 bc 0b c0 05 41 	cmpb   $0x0,0x4105c0(%r11,%r9,1)
  40b215:	00 00 
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40b217:	4d 89 da             	mov    %r11,%r10
                    if (!fcs_is_parent_card(dest_below_card, dest_card))
  40b21a:	75 15                	jne    40b231 <resume_solution+0xf41>
    int8_t *ptr = &positions_by_rank[(dest_card - 4) << 1];
  40b21c:	8d 44 00 f8          	lea    -0x8(%rax,%rax,1),%eax
  40b220:	48 98                	cltq   
  40b222:	48 03 84 24 c0 00 00 	add    0xc0(%rsp),%rax
  40b229:	00 
    *(ptr++) = dest_stack;
  40b22a:	40 88 30             	mov    %sil,(%rax)
                        fc_solve__assign_dest_stack_and_col_ptr(
  40b22d:	40 88 78 01          	mov    %dil,0x1(%rax)
  40b231:	48 83 c7 01          	add    $0x1,%rdi
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40b235:	41 0f be c2          	movsbl %r10b,%eax
                for (int dc = 0; dc < top_card_idx;
  40b239:	39 f9                	cmp    %edi,%ecx
  40b23b:	7f c3                	jg     40b200 <resume_solution+0xf10>
    int8_t *ptr = &positions_by_rank[(dest_card - 4) << 1];
  40b23d:	8d 44 00 f8          	lea    -0x8(%rax,%rax,1),%eax
  40b241:	48 98                	cltq   
  40b243:	48 03 84 24 c0 00 00 	add    0xc0(%rsp),%rax
  40b24a:	00 
    *(ptr++) = dest_stack;
  40b24b:	40 88 30             	mov    %sil,(%rax)
            fc_solve__assign_dest_stack_and_col_ptr(
  40b24e:	88 48 01             	mov    %cl,0x1(%rax)
  40b251:	48 83 c2 01          	add    $0x1,%rdx
        for (int ds = 0; ds < LOCAL_STACKS_NUM; ds++)
  40b255:	48 83 fa 08          	cmp    $0x8,%rdx
  40b259:	75 80                	jne    40b1db <resume_solution+0xeeb>
        derived.num_states = 0;
  40b25b:	48 8d 8c 24 00 01 00 	lea    0x100(%rsp),%rcx
  40b262:	00 
        for (const fcs_move_func *move_func_ptr = moves_list;
  40b263:	48 8b 44 24 48       	mov    0x48(%rsp),%rax
        derived.num_states = 0;
  40b268:	48 c7 84 24 00 01 00 	movq   $0x0,0x100(%rsp)
  40b26f:	00 00 00 00 00 
        for (const fcs_move_func *move_func_ptr = moves_list;
  40b274:	48 89 8c 24 90 00 00 	mov    %rcx,0x90(%rsp)
  40b27b:	00 
  40b27c:	48 8b 8c 24 98 00 00 	mov    0x98(%rsp),%rcx
  40b283:	00 
            move_func_ptr->f(soft_thread, pass, &derived);
  40b284:	48 8b 9c 24 d0 00 00 	mov    0xd0(%rsp),%rbx
  40b28b:	00 
        for (const fcs_move_func *move_func_ptr = moves_list;
  40b28c:	49 89 c5             	mov    %rax,%r13
  40b28f:	48 39 c8             	cmp    %rcx,%rax
  40b292:	73 34                	jae    40b2c8 <resume_solution+0xfd8>
  40b294:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40b29b:	00 00 00 00 
  40b29f:	90                   	nop
            move_func_ptr->f(soft_thread, pass, &derived);
  40b2a0:	48 8b 8c 24 90 00 00 	mov    0x90(%rsp),%rcx
  40b2a7:	00 
  40b2a8:	48 89 de             	mov    %rbx,%rsi
  40b2ab:	4c 89 ff             	mov    %r15,%rdi
  40b2ae:	48 8b 94 24 d8 00 00 	mov    0xd8(%rsp),%rdx
  40b2b5:	00 
  40b2b6:	41 ff 55 00          	callq  *0x0(%r13)
             move_func_ptr < moves_list_end; move_func_ptr++)
  40b2ba:	49 83 c5 08          	add    $0x8,%r13
        for (const fcs_move_func *move_func_ptr = moves_list;
  40b2be:	4c 39 ac 24 98 00 00 	cmp    %r13,0x98(%rsp)
  40b2c5:	00 
  40b2c6:	77 d8                	ja     40b2a0 <resume_solution+0xfb0>
        if (is_a_complete_scan)
  40b2c8:	80 bc 24 a0 00 00 00 	cmpb   $0x0,0xa0(%rsp)
  40b2cf:	00 
  40b2d0:	0f 84 5a 05 00 00    	je     40b830 <resume_solution+0x1540>
            FCS_S_VISITED(PTR_STATE) |= FCS_VISITED_ALL_TESTS_DONE;
  40b2d6:	41 80 4e 56 08       	orb    $0x8,0x56(%r14)
        BUMP_NUM_CHECKED_STATES();
  40b2db:	49 83 04 24 01       	addq   $0x1,(%r12)
        for (derived_end = (derived_iter = derived.states) + derived.num_states;
  40b2e0:	48 8b 84 24 00 01 00 	mov    0x100(%rsp),%rax
  40b2e7:	00 
  40b2e8:	48 8b bc 24 08 01 00 	mov    0x108(%rsp),%rdi
  40b2ef:	00 
  40b2f0:	48 89 c2             	mov    %rax,%rdx
  40b2f3:	48 c1 e2 04          	shl    $0x4,%rdx
  40b2f7:	48 89 bc 24 d0 00 00 	mov    %rdi,0xd0(%rsp)
  40b2fe:	00 
  40b2ff:	48 01 fa             	add    %rdi,%rdx
  40b302:	48 89 94 24 90 00 00 	mov    %rdx,0x90(%rsp)
  40b309:	00 
  40b30a:	48 39 d7             	cmp    %rdx,%rdi
  40b30d:	0f 83 8a 03 00 00    	jae    40b69d <resume_solution+0x13ad>
                fc_solve_pq_push(pqueue, scans_ptr_new_state,
  40b313:	4c 89 74 24 38       	mov    %r14,0x38(%rsp)
  40b318:	4c 8b b4 24 c8 00 00 	mov    0xc8(%rsp),%r14
  40b31f:	00 
  40b320:	eb 6f                	jmp    40b391 <resume_solution+0x10a1>
  40b322:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40b329:	00 00 00 00 
  40b32d:	0f 1f 00             	nopl   (%rax)
                if (my_brfs_recycle_bin)
  40b330:	49 8b 97 e8 00 00 00 	mov    0xe8(%r15),%rdx
  40b337:	48 85 d2             	test   %rdx,%rdx
  40b33a:	0f 84 b0 04 00 00    	je     40b7f0 <resume_solution+0x1500>
                    my_brfs_recycle_bin = my_brfs_recycle_bin->next;
  40b340:	48 8b 42 08          	mov    0x8(%rdx),%rax
  40b344:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
                queue_last_item->s = scans_ptr_new_state;
  40b34b:	48 8b 84 24 e0 00 00 	mov    0xe0(%rsp),%rax
  40b352:	00 
  40b353:	c4 e1 f9 6e eb       	vmovq  %rbx,%xmm5
                last_item_next->next = NULL;
  40b358:	48 89 94 24 e0 00 00 	mov    %rdx,0xe0(%rsp)
  40b35f:	00 
                queue_last_item->s = scans_ptr_new_state;
  40b360:	c4 e3 d1 22 c2 01    	vpinsrq $0x1,%rdx,%xmm5,%xmm0
  40b366:	c5 f8 11 00          	vmovups %xmm0,(%rax)
                last_item_next->next = NULL;
  40b36a:	48 c7 42 08 00 00 00 	movq   $0x0,0x8(%rdx)
  40b371:	00 
             derived_iter < derived_end; derived_iter++)
  40b372:	48 83 84 24 d0 00 00 	addq   $0x10,0xd0(%rsp)
  40b379:	00 10 
  40b37b:	48 8b 84 24 d0 00 00 	mov    0xd0(%rsp),%rax
  40b382:	00 
        for (derived_end = (derived_iter = derived.states) + derived.num_states;
  40b383:	48 3b 84 24 90 00 00 	cmp    0x90(%rsp),%rax
  40b38a:	00 
  40b38b:	0f 83 ff 02 00 00    	jae    40b690 <resume_solution+0x13a0>
            const_AUTO(scans_ptr_new_state, derived_iter->state_ptr);
  40b391:	48 8b 84 24 d0 00 00 	mov    0xd0(%rsp),%rax
  40b398:	00 
            if (is_befs)
  40b399:	80 bc 24 b8 00 00 00 	cmpb   $0x0,0xb8(%rsp)
  40b3a0:	00 
            const_AUTO(scans_ptr_new_state, derived_iter->state_ptr);
  40b3a1:	48 8b 18             	mov    (%rax),%rbx
            if (is_befs)
  40b3a4:	74 8a                	je     40b330 <resume_solution+0x1040>
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40b3a6:	b8 20 4e 00 00       	mov    $0x4e20,%eax
  40b3ab:	2b 43 50             	sub    0x50(%rbx),%eax
  40b3ae:	0f 88 8c 02 00 00    	js     40b640 <resume_solution+0x1350>
  40b3b4:	c5 f1 57 c9          	vxorpd %xmm1,%xmm1,%xmm1
  40b3b8:	c5 e9 57 d2          	vxorpd %xmm2,%xmm2,%xmm2
  40b3bc:	c5 f3 2a c8          	vcvtsi2sd %eax,%xmm1,%xmm1
    if (num_cards_out_lookup_table[1])
  40b3c0:	c4 c1 79 2e 97 40 01 	vucomisd 0x140(%r15),%xmm2
  40b3c7:	00 00 
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40b3c9:	c4 c1 73 59 8f 28 01 	vmulsd 0x128(%r15),%xmm1,%xmm1
  40b3d0:	00 00 
    if (num_cards_out_lookup_table[1])
  40b3d2:	7a 02                	jp     40b3d6 <resume_solution+0x10e6>
  40b3d4:	74 2f                	je     40b405 <resume_solution+0x1115>
            sum += num_cards_out_lookup_table[(
  40b3d6:	48 0f be 53 44       	movsbq 0x44(%rbx),%rdx
    const_PTR(
  40b3db:	49 8d 87 38 01 00 00 	lea    0x138(%r15),%rax
            sum += num_cards_out_lookup_table[(
  40b3e2:	c5 f3 58 0c d0       	vaddsd (%rax,%rdx,8),%xmm1,%xmm1
  40b3e7:	48 0f be 53 45       	movsbq 0x45(%rbx),%rdx
  40b3ec:	c5 f3 58 0c d0       	vaddsd (%rax,%rdx,8),%xmm1,%xmm1
  40b3f1:	48 0f be 53 46       	movsbq 0x46(%rbx),%rdx
  40b3f6:	c5 f3 58 0c d0       	vaddsd (%rax,%rdx,8),%xmm1,%xmm1
  40b3fb:	48 0f be 53 47       	movsbq 0x47(%rbx),%rdx
  40b400:	c5 f3 58 0c d0       	vaddsd (%rax,%rdx,8),%xmm1,%xmm1
    if (weighting->should_go_over_stacks)
  40b405:	41 80 bf 08 01 00 00 	cmpb   $0x0,0x108(%r15)
  40b40c:	00 
  40b40d:	0f 84 89 00 00 00    	je     40b49c <resume_solution+0x11ac>
  40b413:	48 89 de             	mov    %rbx,%rsi
    fcs_game_limit num_vacant_stacks = 0;
  40b416:	31 c9                	xor    %ecx,%ecx
    fcs_seq_cards_power_type seqs_over_renegade_cards = 0;
  40b418:	c5 e1 57 db          	vxorpd %xmm3,%xmm3,%xmm3
    fcs_seq_cards_power_type cards_under_sequences = 0;
  40b41c:	c5 d1 57 ed          	vxorpd %xmm5,%xmm5,%xmm5
  40b420:	4c 8d 6b 40          	lea    0x40(%rbx),%r13
            const_AUTO(col, fcs_state_get_col(*state, a));
  40b424:	4c 8b 06             	mov    (%rsi),%r8
            const int cards_num = fcs_col_len(col);
  40b427:	41 0f be 10          	movsbl (%r8),%edx
            if (cards_num <= 1)
  40b42b:	83 fa 01             	cmp    $0x1,%edx
  40b42e:	0f 8f 1c 02 00 00    	jg     40b650 <resume_solution+0x1360>
                    ++num_vacant_stacks;
  40b434:	80 d1 00             	adc    $0x0,%cl
  40b437:	48 83 c6 08          	add    $0x8,%rsi
        for (int a = 0; a < LOCAL_STACKS_NUM; ++a)
  40b43b:	49 39 f5             	cmp    %rsi,%r13
  40b43e:	75 e4                	jne    40b424 <resume_solution+0x1134>
        if (fcs_freecell_is_empty(*state_ptr, i))
  40b440:	80 7b 40 00          	cmpb   $0x0,0x40(%rbx)
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40b444:	c5 f9 57 c0          	vxorpd %xmm0,%xmm0,%xmm0
                (seqs_over_renegade_cards *
  40b448:	c4 c1 63 59 9f 20 01 	vmulsd 0x120(%r15),%xmm3,%xmm3
  40b44f:	00 00 
        if (fcs_freecell_is_empty(*state_ptr, i))
  40b451:	0f 94 c0             	sete   %al
            num_vacant_freecells++;
  40b454:	80 7b 41 01          	cmpb   $0x1,0x41(%rbx)
  40b458:	14 00                	adc    $0x0,%al
  40b45a:	80 7b 42 01          	cmpb   $0x1,0x42(%rbx)
  40b45e:	14 00                	adc    $0x0,%al
  40b460:	80 7b 43 01          	cmpb   $0x1,0x43(%rbx)
  40b464:	14 00                	adc    $0x0,%al
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40b466:	0f b6 c0             	movzbl %al,%eax
  40b469:	83 c0 01             	add    $0x1,%eax
  40b46c:	d3 e0                	shl    %cl,%eax
  40b46e:	c5 fb 2a c0          	vcvtsi2sd %eax,%xmm0,%xmm0
                ((instance->initial_cards_under_sequences_value -
  40b472:	49 8b 07             	mov    (%r15),%rax
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40b475:	c4 c1 7b 59 87 10 01 	vmulsd 0x110(%r15),%xmm0,%xmm0
  40b47c:	00 00 
                ((instance->initial_cards_under_sequences_value -
  40b47e:	c5 fb 10 60 08       	vmovsd 0x8(%rax),%xmm4
  40b483:	c5 db 5c e5          	vsubsd %xmm5,%xmm4,%xmm4
                     cards_under_sequences) *
  40b487:	c4 c1 5b 59 a7 18 01 	vmulsd 0x118(%r15),%xmm4,%xmm4
  40b48e:	00 00 
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40b490:	c5 fb 58 c4          	vaddsd %xmm4,%xmm0,%xmm0
                    weighting->cards_under_sequences_factor) +
  40b494:	c5 fb 58 c3          	vaddsd %xmm3,%xmm0,%xmm0
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40b498:	c5 f3 58 c8          	vaddsd %xmm0,%xmm1,%xmm1
    const double num_cards_not_on_parents_weight =
  40b49c:	c4 c1 7b 10 9f 30 01 	vmovsd 0x130(%r15),%xmm3
  40b4a3:	00 00 
    if (num_cards_not_on_parents_weight)
  40b4a5:	c5 f9 2e da          	vucomisd %xmm2,%xmm3
  40b4a9:	7a 06                	jp     40b4b1 <resume_solution+0x11c1>
  40b4ab:	0f 84 c2 00 00 00    	je     40b573 <resume_solution+0x1283>
  40b4b1:	4c 8d 5b 40          	lea    0x40(%rbx),%r11
  40b4b5:	48 89 df             	mov    %rbx,%rdi
        int num_cards_not_on_parents = (LOCAL_DECKS_NUM * 52);
  40b4b8:	ba 34 00 00 00       	mov    $0x34,%edx
            const_AUTO(col, fcs_state_get_col(*state, stack_idx));
  40b4bd:	48 8b 0f             	mov    (%rdi),%rcx
            const uint_fast16_t col_len = fcs_col_len(col);
  40b4c0:	4c 0f be 09          	movsbq (%rcx),%r9
            for (uint_fast16_t h = 1; h < col_len; h++)
  40b4c4:	49 83 f9 01          	cmp    $0x1,%r9
  40b4c8:	0f 86 88 00 00 00    	jbe    40b556 <resume_solution+0x1266>
  40b4ce:	41 80 f9 03          	cmp    $0x3,%r9b
  40b4d2:	0f 86 58 01 00 00    	jbe    40b630 <resume_solution+0x1340>
  40b4d8:	4c 0f be 41 01       	movsbq 0x1(%rcx),%r8
  40b4dd:	49 8d 71 fc          	lea    -0x4(%r9),%rsi
  40b4e1:	b8 01 00 00 00       	mov    $0x1,%eax
  40b4e6:	48 83 e6 fe          	and    $0xfffffffffffffffe,%rsi
  40b4ea:	48 83 c6 03          	add    $0x3,%rsi
  40b4ee:	4c 0f be 54 01 01    	movsbq 0x1(%rcx,%rax,1),%r10
  40b4f4:	4d 89 d5             	mov    %r10,%r13
  40b4f7:	49 c1 e5 06          	shl    $0x6,%r13
  40b4fb:	4f 8d 84 05 c0 05 41 	lea    0x4105c0(%r13,%r8,1),%r8
  40b502:	00 
                    num_cards_not_on_parents--;
  40b503:	41 80 38 01          	cmpb   $0x1,(%r8)
  40b507:	83 da 00             	sbb    $0x0,%edx
                if (!fcs_is_parent_card(
  40b50a:	48 83 c0 02          	add    $0x2,%rax
  40b50e:	4c 0f be 04 01       	movsbq (%rcx,%rax,1),%r8
  40b513:	4d 89 c5             	mov    %r8,%r13
  40b516:	49 c1 e5 06          	shl    $0x6,%r13
  40b51a:	4f 8d 94 2a c0 05 41 	lea    0x4105c0(%r10,%r13,1),%r10
  40b521:	00 
                    num_cards_not_on_parents--;
  40b522:	41 80 3a 01          	cmpb   $0x1,(%r10)
  40b526:	83 da 00             	sbb    $0x0,%edx
  40b529:	48 39 c6             	cmp    %rax,%rsi
  40b52c:	75 c0                	jne    40b4ee <resume_solution+0x11fe>
  40b52e:	66 90                	xchg   %ax,%ax
                        fcs_col_get_card(col, h - 1), fcs_col_get_card(col, h)))
  40b530:	48 83 c0 01          	add    $0x1,%rax
  40b534:	48 0f be 34 01       	movsbq (%rcx,%rax,1),%rsi
  40b539:	4c 0f be 44 01 ff    	movsbq -0x1(%rcx,%rax,1),%r8
  40b53f:	48 c1 e6 06          	shl    $0x6,%rsi
  40b543:	49 8d b4 30 c0 05 41 	lea    0x4105c0(%r8,%rsi,1),%rsi
  40b54a:	00 
                    num_cards_not_on_parents--;
  40b54b:	80 3e 01             	cmpb   $0x1,(%rsi)
  40b54e:	83 da 00             	sbb    $0x0,%edx
            for (uint_fast16_t h = 1; h < col_len; h++)
  40b551:	49 39 c1             	cmp    %rax,%r9
  40b554:	77 da                	ja     40b530 <resume_solution+0x1240>
  40b556:	48 83 c7 08          	add    $0x8,%rdi
        for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  40b55a:	49 39 fb             	cmp    %rdi,%r11
  40b55d:	0f 85 5a ff ff ff    	jne    40b4bd <resume_solution+0x11cd>
        sum += num_cards_not_on_parents * num_cards_not_on_parents_weight;
  40b563:	c5 f9 57 c0          	vxorpd %xmm0,%xmm0,%xmm0
  40b567:	c5 fb 2a c2          	vcvtsi2sd %edx,%xmm0,%xmm0
  40b56b:	c5 fb 59 c3          	vmulsd %xmm3,%xmm0,%xmm0
  40b56f:	c5 f3 58 c8          	vaddsd %xmm0,%xmm1,%xmm1
    return ((int)sum);
  40b573:	c5 fb 2c d1          	vcvttsd2si %xmm1,%edx
   "r" is the rating of the item you're adding for sorting purposes */

static inline void fc_solve_pq_push(
    pri_queue *const pq, fcs_collectible_state *const val, const pq_rating r)
{
    var_AUTO(i, ++(pq->current_size));
  40b577:	49 8b 46 08          	mov    0x8(%r14),%rax

    if (i > pq->max_size)
  40b57b:	49 8b 36             	mov    (%r14),%rsi
    var_AUTO(i, ++(pq->current_size));
  40b57e:	4c 8d 68 01          	lea    0x1(%rax),%r13
  40b582:	49 8b 46 10          	mov    0x10(%r14),%rax
  40b586:	4d 89 6e 08          	mov    %r13,0x8(%r14)
    if (i > pq->max_size)
  40b58a:	49 39 f5             	cmp    %rsi,%r13
  40b58d:	77 71                	ja     40b600 <resume_solution+0x1310>

    while (
        (i == PQ_FIRST_ENTRY ? (FC_SOLVE_PQUEUE_MaxRating) /* return biggest
                                                              possible rating if
                                                              first element */
                             : (fcs_pq_rating(elems[PQ_PARENT_INDEX(i)]))) < r)
  40b58f:	49 83 fd 01          	cmp    $0x1,%r13
  40b593:	74 53                	je     40b5e8 <resume_solution+0x12f8>
  40b595:	4c 89 e9             	mov    %r13,%rcx
  40b598:	48 d1 e9             	shr    %rcx
  40b59b:	48 c1 e1 04          	shl    $0x4,%rcx
    while (
  40b59f:	39 54 08 08          	cmp    %edx,0x8(%rax,%rcx,1)
  40b5a3:	7c 1f                	jl     40b5c4 <resume_solution+0x12d4>
  40b5a5:	e9 12 23 00 00       	jmpq   40d8bc <resume_solution+0x35cc>
  40b5aa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                             : (fcs_pq_rating(elems[PQ_PARENT_INDEX(i)]))) < r)
  40b5b0:	49 c1 ed 02          	shr    $0x2,%r13
  40b5b4:	4c 89 ee             	mov    %r13,%rsi
  40b5b7:	49 89 cd             	mov    %rcx,%r13
  40b5ba:	48 c1 e6 04          	shl    $0x4,%rsi
    while (
  40b5be:	39 54 30 08          	cmp    %edx,0x8(%rax,%rsi,1)
  40b5c2:	7d 29                	jge    40b5ed <resume_solution+0x12fd>
    {
        elems[i] = elems[PQ_PARENT_INDEX(i)];
  40b5c4:	4c 89 e9             	mov    %r13,%rcx
  40b5c7:	4c 89 ee             	mov    %r13,%rsi
  40b5ca:	48 d1 e9             	shr    %rcx
  40b5cd:	48 c1 e6 04          	shl    $0x4,%rsi
  40b5d1:	48 89 cf             	mov    %rcx,%rdi
  40b5d4:	48 c1 e7 04          	shl    $0x4,%rdi
  40b5d8:	c5 fa 6f 3c 38       	vmovdqu (%rax,%rdi,1),%xmm7
  40b5dd:	c5 f8 11 3c 30       	vmovups %xmm7,(%rax,%rsi,1)
                             : (fcs_pq_rating(elems[PQ_PARENT_INDEX(i)]))) < r)
  40b5e2:	48 83 f9 01          	cmp    $0x1,%rcx
  40b5e6:	75 c8                	jne    40b5b0 <resume_solution+0x12c0>
            for (uint_fast16_t h = 1; h < col_len; h++)
  40b5e8:	bf 10 00 00 00       	mov    $0x10,%edi

        i = PQ_PARENT_INDEX(i);
    }

    /* then add the element at the space we created. */
    elems[i].val = val;
  40b5ed:	48 01 f8             	add    %rdi,%rax
  40b5f0:	48 89 18             	mov    %rbx,(%rax)
    elems[i].rating = r;
  40b5f3:	89 50 08             	mov    %edx,0x8(%rax)
  40b5f6:	e9 77 fd ff ff       	jmpq   40b372 <resume_solution+0x1082>
  40b5fb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        pq->elems = SREALLOC(pq->elems, (pq->max_size += 256) + 1);
  40b600:	48 8d 8e 00 01 00 00 	lea    0x100(%rsi),%rcx
  40b607:	48 89 c7             	mov    %rax,%rdi
  40b60a:	89 54 24 30          	mov    %edx,0x30(%rsp)
  40b60e:	48 81 c6 01 01 00 00 	add    $0x101,%rsi
  40b615:	49 89 0e             	mov    %rcx,(%r14)
  40b618:	48 c1 e6 04          	shl    $0x4,%rsi
  40b61c:	e8 4f 5b ff ff       	callq  401170 <realloc@plt>
  40b621:	8b 54 24 30          	mov    0x30(%rsp),%edx
  40b625:	49 89 46 10          	mov    %rax,0x10(%r14)
  40b629:	e9 61 ff ff ff       	jmpq   40b58f <resume_solution+0x129f>
  40b62e:	66 90                	xchg   %ax,%ax
  40b630:	b8 01 00 00 00       	mov    $0x1,%eax
  40b635:	e9 f6 fe ff ff       	jmpq   40b530 <resume_solution+0x1240>
  40b63a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40b640:	c5 e9 57 d2          	vxorpd %xmm2,%xmm2,%xmm2
  40b644:	c5 f1 57 c9          	vxorpd %xmm1,%xmm1,%xmm1
  40b648:	e9 73 fd ff ff       	jmpq   40b3c0 <resume_solution+0x10d0>
  40b64d:	0f 1f 00             	nopl   (%rax)
            const int c = update_col_cards_under_sequences(
  40b650:	8d 42 ff             	lea    -0x1(%rdx),%eax
    fcs_card this_card = fcs_col_get_card(col, d);
  40b653:	48 98                	cltq   
  40b655:	49 0f be 7c 00 01    	movsbq 0x1(%r8,%rax,1),%rdi
             prev_card = fcs_col_get_card(col, d - 1);
  40b65b:	4d 0f be 0c 00       	movsbq (%r8,%rax,1),%r9
  40b660:	41 89 c2             	mov    %eax,%r10d
  40b663:	4d 89 cb             	mov    %r9,%r11
  40b666:	49 c1 e1 06          	shl    $0x6,%r9
    for (; (d > 0) && ({
  40b66a:	42 80 bc 0f c0 05 41 	cmpb   $0x0,0x4105c0(%rdi,%r9,1)
  40b671:	00 00 
  40b673:	0f 84 07 02 00 00    	je     40b880 <resume_solution+0x1590>
  40b679:	48 83 e8 01          	sub    $0x1,%rax
         d--, this_card = prev_card)
  40b67d:	49 0f be fb          	movsbq %r11b,%rdi
    for (; (d > 0) && ({
  40b681:	85 c0                	test   %eax,%eax
  40b683:	75 d6                	jne    40b65b <resume_solution+0x136b>
            cards_under_sequences += FCS_SEQS_OVER_RENEGADE_POWER(c);
  40b685:	c5 d3 58 ea          	vaddsd %xmm2,%xmm5,%xmm5
            if (c > 0)
  40b689:	e9 a9 fd ff ff       	jmpq   40b437 <resume_solution+0x1147>
  40b68e:	66 90                	xchg   %ax,%ax
  40b690:	4c 8b 74 24 38       	mov    0x38(%rsp),%r14
  40b695:	48 8b 84 24 00 01 00 	mov    0x100(%rsp),%rax
  40b69c:	00 
    (FCS_S_SCAN_VISITED(ptr_state))[scan_id >> FCS_CHAR_BIT_SIZE_LOG2] |=
  40b69d:	48 8b 4c 24 70       	mov    0x70(%rsp),%rcx
  40b6a2:	0f b6 b4 24 80 00 00 	movzbl 0x80(%rsp),%esi
  40b6a9:	00 
                    MARK_AS_DEAD_END(PTR_STATE);
  40b6aa:	0f b6 bc 24 a0 00 00 	movzbl 0xa0(%rsp),%edi
  40b6b1:	00 
  40b6b2:	41 08 74 0e 57       	or     %sil,0x57(%r14,%rcx,1)
  40b6b7:	40 84 7c 24 60       	test   %dil,0x60(%rsp)
  40b6bc:	0f 84 d2 f8 ff ff    	je     40af94 <resume_solution+0xca4>
  40b6c2:	48 85 c0             	test   %rax,%rax
  40b6c5:	0f 85 c9 f8 ff ff    	jne    40af94 <resume_solution+0xca4>
  40b6cb:	49 8b 46 48          	mov    0x48(%r14),%rax
    FCS_S_VISITED(temp_state) |= FCS_VISITED_DEAD_END;
  40b6cf:	41 80 4e 56 04       	orb    $0x4,0x56(%r14)
    if (temp_state != NULL)
  40b6d4:	48 85 c0             	test   %rax,%rax
  40b6d7:	0f 84 b7 f8 ff ff    	je     40af94 <resume_solution+0xca4>
        --(FCS_S_NUM_ACTIVE_CHILDREN(temp_state));
  40b6dd:	0f b7 48 54          	movzwl 0x54(%rax),%ecx
  40b6e1:	8d 51 ff             	lea    -0x1(%rcx),%edx
  40b6e4:	66 89 50 54          	mov    %dx,0x54(%rax)
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40b6e8:	66 85 d2             	test   %dx,%dx
  40b6eb:	74 3a                	je     40b727 <resume_solution+0x1437>
  40b6ed:	e9 a2 f8 ff ff       	jmpq   40af94 <resume_solution+0xca4>
  40b6f2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40b6f9:	00 00 00 00 
  40b6fd:	0f 1f 00             	nopl   (%rax)
            FCS_S_VISITED(temp_state) |= FCS_VISITED_DEAD_END;
  40b700:	83 ca 04             	or     $0x4,%edx
  40b703:	88 50 56             	mov    %dl,0x56(%rax)
            temp_state = FCS_S_PARENT(temp_state);
  40b706:	48 8b 40 48          	mov    0x48(%rax),%rax
            if (temp_state == NULL)
  40b70a:	48 85 c0             	test   %rax,%rax
  40b70d:	0f 84 81 f8 ff ff    	je     40af94 <resume_solution+0xca4>
            (FCS_S_NUM_ACTIVE_CHILDREN(temp_state))--;
  40b713:	0f b7 70 54          	movzwl 0x54(%rax),%esi
  40b717:	8d 56 ff             	lea    -0x1(%rsi),%edx
  40b71a:	66 89 50 54          	mov    %dx,0x54(%rax)
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40b71e:	66 85 d2             	test   %dx,%dx
  40b721:	0f 85 6d f8 ff ff    	jne    40af94 <resume_solution+0xca4>
               (FCS_S_VISITED(temp_state) & FCS_VISITED_ALL_TESTS_DONE))
  40b727:	0f b6 50 56          	movzbl 0x56(%rax),%edx
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40b72b:	f6 c2 08             	test   $0x8,%dl
  40b72e:	75 d0                	jne    40b700 <resume_solution+0x1410>
            if (is_befs)
  40b730:	80 bc 24 b8 00 00 00 	cmpb   $0x0,0xb8(%rsp)
  40b737:	00 
  40b738:	0f 84 64 f8 ff ff    	je     40afa2 <resume_solution+0xcb2>
  40b73e:	66 90                	xchg   %ax,%ax
 * */

static inline void fc_solve_pq_pop(
    pri_queue *const pq, fcs_collectible_state **const val)
{
    if (fc_solve_is_pqueue_empty(pq))
  40b740:	48 8b 84 24 c8 00 00 	mov    0xc8(%rsp),%rax
  40b747:	00 
  40b748:	48 8b 50 08          	mov    0x8(%rax),%rdx
  40b74c:	48 85 d2             	test   %rdx,%rdx
  40b74f:	0f 84 bb f8 ff ff    	je     40b010 <resume_solution+0xd20>
    {
        *val = NULL;
        return;
    }
    const_SLOT(elems, pq);
  40b755:	48 8b 70 10          	mov    0x10(%rax),%rsi
    const_SLOT(current_size, pq);
    *val = elems[PQ_FIRST_ENTRY].val;

    /* get pointer to last element in tree */
    const_AUTO(last_elem, elems[current_size]);
  40b759:	48 89 d0             	mov    %rdx,%rax

    const_AUTO(new_current_size, current_size - 1);
  40b75c:	48 83 ea 01          	sub    $0x1,%rdx
    const_AUTO(last_elem, elems[current_size]);
  40b760:	48 c1 e0 04          	shl    $0x4,%rax
  40b764:	48 01 f0             	add    %rsi,%rax
    *val = elems[PQ_FIRST_ENTRY].val;
  40b767:	4c 8b 76 10          	mov    0x10(%rsi),%r14
    const_AUTO(last_elem, elems[current_size]);
  40b76b:	4c 8b 28             	mov    (%rax),%r13
  40b76e:	44 8b 50 08          	mov    0x8(%rax),%r10d

    /*  UNTESTED */

    size_t i;
    size_t child;
    for (i = PQ_FIRST_ENTRY;
  40b772:	48 83 fa 01          	cmp    $0x1,%rdx
  40b776:	0f 86 74 0c 00 00    	jbe    40c3f0 <resume_solution+0x2100>
  40b77c:	b8 01 00 00 00       	mov    $0x1,%eax
         (child = PQ_LEFT_CHILD_INDEX(i)) <= new_current_size; i = child)
  40b781:	b9 02 00 00 00       	mov    $0x2,%ecx
  40b786:	eb 33                	jmp    40b7bb <resume_solution+0x14cb>
  40b788:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40b78f:	00 
    {
        /* set child to the smaller of the two children... */

        if ((child != new_current_size) &&
  40b790:	49 89 c8             	mov    %rcx,%r8
    return elem.rating;
  40b793:	48 c1 e0 04          	shl    $0x4,%rax
  40b797:	48 01 f0             	add    %rsi,%rax
            (fcs_pq_rating(elems[child + 1]) > fcs_pq_rating(elems[child])))
        {
            child++;
        }

        if (fcs_pq_rating(last_elem) < fcs_pq_rating(elems[child]))
  40b79a:	45 39 ca             	cmp    %r9d,%r10d
  40b79d:	0f 8d c0 01 00 00    	jge    40b963 <resume_solution+0x1673>
        {
            elems[i] = elems[child];
  40b7a3:	c5 fa 6f 1f          	vmovdqu (%rdi),%xmm3
         (child = PQ_LEFT_CHILD_INDEX(i)) <= new_current_size; i = child)
  40b7a7:	4b 8d 0c 00          	lea    (%r8,%r8,1),%rcx
            elems[i] = elems[child];
  40b7ab:	c5 f8 11 18          	vmovups %xmm3,(%rax)
         (child = PQ_LEFT_CHILD_INDEX(i)) <= new_current_size; i = child)
  40b7af:	4c 89 c0             	mov    %r8,%rax
    for (i = PQ_FIRST_ENTRY;
  40b7b2:	48 39 ca             	cmp    %rcx,%rdx
  40b7b5:	0f 82 a5 01 00 00    	jb     40b960 <resume_solution+0x1670>
        if ((child != new_current_size) &&
  40b7bb:	49 89 cb             	mov    %rcx,%r11
  40b7be:	49 89 d0             	mov    %rdx,%r8
  40b7c1:	49 c1 e3 04          	shl    $0x4,%r11
  40b7c5:	4a 8d 3c 1e          	lea    (%rsi,%r11,1),%rdi
  40b7c9:	44 8b 4f 08          	mov    0x8(%rdi),%r9d
  40b7cd:	48 39 d1             	cmp    %rdx,%rcx
  40b7d0:	74 c1                	je     40b793 <resume_solution+0x14a3>
            (fcs_pq_rating(elems[child + 1]) > fcs_pq_rating(elems[child])))
  40b7d2:	4e 8d 5c 1e 10       	lea    0x10(%rsi,%r11,1),%r11
  40b7d7:	41 8b 5b 08          	mov    0x8(%r11),%ebx
  40b7db:	4c 8d 41 01          	lea    0x1(%rcx),%r8
        if ((child != new_current_size) &&
  40b7df:	44 39 cb             	cmp    %r9d,%ebx
  40b7e2:	7e ac                	jle    40b790 <resume_solution+0x14a0>
  40b7e4:	41 89 d9             	mov    %ebx,%r9d
  40b7e7:	4c 89 df             	mov    %r11,%rdi
  40b7ea:	eb a7                	jmp    40b793 <resume_solution+0x14a3>
  40b7ec:	0f 1f 40 00          	nopl   0x0(%rax)
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  40b7f0:	49 8b 94 24 e8 00 00 	mov    0xe8(%r12),%rdx
  40b7f7:	00 
  40b7f8:	49 8b 84 24 e0 00 00 	mov    0xe0(%r12),%rax
  40b7ff:	00 
  40b800:	48 29 d0             	sub    %rdx,%rax
  40b803:	48 83 f8 0f          	cmp    $0xf,%rax
  40b807:	0f 86 93 00 00 00    	jbe    40b8a0 <resume_solution+0x15b0>
        allocator->rollback_ptr = allocator->ptr;
  40b80d:	49 89 94 24 f0 00 00 	mov    %rdx,0xf0(%r12)
  40b814:	00 
    allocator->ptr += how_much;
  40b815:	48 8d 42 10          	lea    0x10(%rdx),%rax
  40b819:	49 89 84 24 e8 00 00 	mov    %rax,0xe8(%r12)
  40b820:	00 
    return allocator->rollback_ptr;
  40b821:	e9 25 fb ff ff       	jmpq   40b34b <resume_solution+0x105b>
  40b826:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40b82d:	00 00 00 
        BUMP_NUM_CHECKED_STATES();
  40b830:	49 83 04 24 01       	addq   $0x1,(%r12)
        for (derived_end = (derived_iter = derived.states) + derived.num_states;
  40b835:	48 8b 84 24 00 01 00 	mov    0x100(%rsp),%rax
  40b83c:	00 
  40b83d:	48 8b b4 24 08 01 00 	mov    0x108(%rsp),%rsi
  40b844:	00 
  40b845:	48 c1 e0 04          	shl    $0x4,%rax
  40b849:	48 01 f0             	add    %rsi,%rax
  40b84c:	48 89 b4 24 d0 00 00 	mov    %rsi,0xd0(%rsp)
  40b853:	00 
  40b854:	48 89 84 24 90 00 00 	mov    %rax,0x90(%rsp)
  40b85b:	00 
  40b85c:	48 39 f0             	cmp    %rsi,%rax
  40b85f:	0f 87 ae fa ff ff    	ja     40b313 <resume_solution+0x1023>
  40b865:	48 8b 44 24 70       	mov    0x70(%rsp),%rax
  40b86a:	0f b6 b4 24 80 00 00 	movzbl 0x80(%rsp),%esi
  40b871:	00 
  40b872:	41 08 74 06 57       	or     %sil,0x57(%r14,%rax,1)
                    MARK_AS_DEAD_END(PTR_STATE);
  40b877:	e9 18 f7 ff ff       	jmpq   40af94 <resume_solution+0xca4>
  40b87c:	0f 1f 40 00          	nopl   0x0(%rax)
                            : FCS_SEQS_OVER_RENEGADE_POWER(cards_num - c));
  40b880:	44 29 d2             	sub    %r10d,%edx
            cards_under_sequences += FCS_SEQS_OVER_RENEGADE_POWER(c);
  40b883:	48 98                	cltq   
  40b885:	c5 d3 58 2c c5 a0 fd 	vaddsd 0x40fda0(,%rax,8),%xmm5,%xmm5
  40b88c:	40 00 
                            : FCS_SEQS_OVER_RENEGADE_POWER(cards_num - c));
  40b88e:	48 63 d2             	movslq %edx,%rdx
                seqs_over_renegade_cards +=
  40b891:	c5 e3 58 1c d5 a0 fd 	vaddsd 0x40fda0(,%rdx,8),%xmm3,%xmm3
  40b898:	40 00 
  40b89a:	e9 98 fb ff ff       	jmpq   40b437 <resume_solution+0x1147>
  40b89f:	90                   	nop
    char *const new_data = meta_request_new_buffer(allocator->meta);
  40b8a0:	49 8b 94 24 f8 00 00 	mov    0xf8(%r12),%rdx
  40b8a7:	00 
    char *const ret = meta_alloc->recycle_bin;
  40b8a8:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40b8ab:	48 85 c0             	test   %rax,%rax
  40b8ae:	0f 84 8c 01 00 00    	je     40ba40 <resume_solution+0x1750>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40b8b4:	48 8b 08             	mov    (%rax),%rcx
  40b8b7:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40b8ba:	49 8b 94 24 d8 00 00 	mov    0xd8(%r12),%rdx
  40b8c1:	00 
  40b8c2:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40b8c5:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  40b8c9:	49 89 84 24 d8 00 00 	mov    %rax,0xd8(%r12)
  40b8d0:	00 
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40b8d1:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40b8d7:	49 89 94 24 f0 00 00 	mov    %rdx,0xf0(%r12)
  40b8de:	00 
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40b8df:	49 89 84 24 e0 00 00 	mov    %rax,0xe0(%r12)
  40b8e6:	00 
  40b8e7:	e9 29 ff ff ff       	jmpq   40b815 <resume_solution+0x1525>
  40b8ec:	0f 1f 40 00          	nopl   0x0(%rax)
    if (derived.states != NULL)
  40b8f0:	48 8b bc 24 08 01 00 	mov    0x108(%rsp),%rdi
  40b8f7:	00 
  40b8f8:	48 85 ff             	test   %rdi,%rdi
  40b8fb:	0f 84 ff 0a 00 00    	je     40c400 <resume_solution+0x2110>
  40b901:	bb 01 00 00 00       	mov    $0x1,%ebx
    error_code = FCS_STATE_IS_NOT_SOLVEABLE;
  40b906:	41 bd 01 00 00 00    	mov    $0x1,%r13d
        free(derived.states);
  40b90c:	e8 3f 57 ff ff       	callq  401050 <free@plt>
    if (!is_befs)
  40b911:	80 bc 24 b8 00 00 00 	cmpb   $0x0,0xb8(%rsp)
  40b918:	00 
  40b919:	0f 85 11 f7 ff ff    	jne    40b030 <resume_solution+0xd40>
        my_brfs_queue_last_item = queue_last_item;
  40b91f:	48 8b 84 24 e0 00 00 	mov    0xe0(%rsp),%rax
  40b926:	00 
  40b927:	49 89 87 e0 00 00 00 	mov    %rax,0xe0(%r15)
    return error_code;
  40b92e:	e9 fd f6 ff ff       	jmpq   40b030 <resume_solution+0xd40>
  40b933:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40b93a:	00 00 00 00 
  40b93e:	66 90                	xchg   %ax,%ax
            ASSIGN_ptr_state(new_ptr_state);
  40b940:	bb 01 00 00 00       	mov    $0x1,%ebx
    error_code = FCS_STATE_IS_NOT_SOLVEABLE;
  40b945:	41 bd 01 00 00 00    	mov    $0x1,%r13d
    if (derived.states != NULL)
  40b94b:	48 8b bc 24 08 01 00 	mov    0x108(%rsp),%rdi
  40b952:	00 
  40b953:	48 85 ff             	test   %rdi,%rdi
  40b956:	75 b4                	jne    40b90c <resume_solution+0x161c>
  40b958:	eb b7                	jmp    40b911 <resume_solution+0x1621>
  40b95a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
    for (i = PQ_FIRST_ENTRY;
  40b960:	48 89 f8             	mov    %rdi,%rax
        {
            break;
        }
    }

    elems[i] = last_elem;
  40b963:	44 89 50 08          	mov    %r10d,0x8(%rax)
  40b967:	4c 89 28             	mov    %r13,(%rax)
    pq->current_size = new_current_size;
  40b96a:	48 8b 84 24 c8 00 00 	mov    0xc8(%rsp),%rax
  40b971:	00 
  40b972:	48 89 50 08          	mov    %rdx,0x8(%rax)
  40b976:	e9 5e f6 ff ff       	jmpq   40afd9 <resume_solution+0xce9>
  40b97b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            if (++(HT_FIELD(hard_thread, num_soft_threads_finished)) ==
  40b980:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40b987:	00 
            STRUCT_TURN_ON_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED);
  40b988:	41 c6 87 e0 01 00 00 	movb   $0x1,0x1e0(%r15)
  40b98f:	01 
            if (++(HT_FIELD(hard_thread, num_soft_threads_finished)) ==
  40b990:	8b b8 28 05 00 00    	mov    0x528(%rax),%edi
  40b996:	8d 4f 01             	lea    0x1(%rdi),%ecx
  40b999:	89 bc 24 d0 00 00 00 	mov    %edi,0xd0(%rsp)
  40b9a0:	89 88 28 05 00 00    	mov    %ecx,0x528(%rax)
  40b9a6:	48 63 c9             	movslq %ecx,%rcx
  40b9a9:	48 39 8c 24 88 00 00 	cmp    %rcx,0x88(%rsp)
  40b9b0:	00 
  40b9b1:	75 08                	jne    40b9bb <resume_solution+0x16cb>
                ++instance->num_hard_threads_finished;
  40b9b3:	48 83 80 40 05 00 00 	addq   $0x1,0x540(%rax)
  40b9ba:	01 
            if (STRUCT_QUERY_FLAG(
  40b9bb:	41 80 bf e2 01 00 00 	cmpb   $0x0,0x1e2(%r15)
  40b9c2:	00 
  40b9c3:	74 15                	je     40b9da <resume_solution+0x16ea>
                    soft_thread, FCS_SOFT_THREAD_IS_A_COMPLETE_SCAN) &&
  40b9c5:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40b9cc:	00 
  40b9cd:	80 b8 b8 00 00 00 00 	cmpb   $0x0,0xb8(%rax)
  40b9d4:	0f 84 26 16 00 00    	je     40d000 <resume_solution+0x2d10>
                ret = FCS_STATE_SUSPEND_PROCESS;
  40b9da:	41 bd 05 00 00 00    	mov    $0x5,%r13d
  40b9e0:	e9 9b ea ff ff       	jmpq   40a480 <resume_solution+0x190>
  40b9e5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40b9ec:	00 00 00 00 
    if (HT_FIELD(hard_thread, prelude_idx) < prelude_num_items)
  40b9f0:	48 89 c7             	mov    %rax,%rdi
  40b9f3:	48 8b 80 08 05 00 00 	mov    0x508(%rax),%rax
  40b9fa:	48 39 44 24 58       	cmp    %rax,0x58(%rsp)
  40b9ff:	76 4f                	jbe    40ba50 <resume_solution+0x1760>
        prelude[HT_FIELD(hard_thread, prelude_idx)++];
  40ba01:	48 8d 50 01          	lea    0x1(%rax),%rdx
  40ba05:	48 c1 e0 04          	shl    $0x4,%rax
  40ba09:	48 03 44 24 50       	add    0x50(%rsp),%rax
  40ba0e:	48 89 97 08 05 00 00 	mov    %rdx,0x508(%rdi)
    set_next_soft_thread(
  40ba15:	48 8b 50 08          	mov    0x8(%rax),%rdx
    (*st_idx_ptr) = scan_idx;
  40ba19:	48 8b 00             	mov    (%rax),%rax
  40ba1c:	48 89 87 d0 00 00 00 	mov    %rax,0xd0(%rdi)
        NUM_CHECKED_STATES + quota;
  40ba23:	48 8d 04 16          	lea    (%rsi,%rdx,1),%rax
  40ba27:	48 89 87 c8 00 00 00 	mov    %rax,0xc8(%rdi)
  40ba2e:	e9 15 f6 ff ff       	jmpq   40b048 <resume_solution+0xd58>
  40ba33:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40ba3a:	00 00 00 00 
  40ba3e:	66 90                	xchg   %ax,%ax
        return malloc(ALLOCED_SIZE);
  40ba40:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40ba45:	e8 a6 56 ff ff       	callq  4010f0 <malloc@plt>
  40ba4a:	e9 6b fe ff ff       	jmpq   40b8ba <resume_solution+0x15ca>
  40ba4f:	90                   	nop
            ((1 + (*st_idx_ptr)) % num_soft_threads);
  40ba50:	48 8b bc 24 e8 00 00 	mov    0xe8(%rsp),%rdi
  40ba57:	00 
        set_next_soft_thread(hard_thread, next_st_idx,
  40ba58:	48 8b 4c 24 78       	mov    0x78(%rsp),%rcx
            ((1 + (*st_idx_ptr)) % num_soft_threads);
  40ba5d:	48 8b 87 d0 00 00 00 	mov    0xd0(%rdi),%rax
  40ba64:	48 89 84 24 d0 00 00 	mov    %rax,0xd0(%rsp)
  40ba6b:	00 
  40ba6c:	48 83 c0 01          	add    $0x1,%rax
        const int_fast32_t next_st_idx =
  40ba70:	48 99                	cqto   
  40ba72:	48 f7 bc 24 88 00 00 	idivq  0x88(%rsp)
  40ba79:	00 
        set_next_soft_thread(hard_thread, next_st_idx,
  40ba7a:	48 69 c2 f8 01 00 00 	imul   $0x1f8,%rdx,%rax
  40ba81:	48 8b 84 01 e8 01 00 	mov    0x1e8(%rcx,%rax,1),%rax
  40ba88:	00 
    (*st_idx_ptr) = scan_idx;
  40ba89:	48 89 97 d0 00 00 00 	mov    %rdx,0xd0(%rdi)
        NUM_CHECKED_STATES + quota;
  40ba90:	48 01 f0             	add    %rsi,%rax
  40ba93:	48 89 87 c8 00 00 00 	mov    %rax,0xc8(%rdi)
  40ba9a:	e9 a9 f5 ff ff       	jmpq   40b048 <resume_solution+0xd58>
  40ba9f:	90                   	nop
        queue = my_brfs_queue;
  40baa0:	49 8b 87 d8 00 00 00 	mov    0xd8(%r15),%rax
  40baa7:	48 89 84 24 a8 00 00 	mov    %rax,0xa8(%rsp)
  40baae:	00 
        queue_last_item = my_brfs_queue_last_item;
  40baaf:	49 8b 87 e0 00 00 00 	mov    0xe0(%r15),%rax
  40bab6:	48 89 84 24 e0 00 00 	mov    %rax,0xe0(%rsp)
  40babd:	00 
    const_AUTO(max_num_states, calc_ht_max_num_states(instance, hard_thread));
  40babe:	49 8b 84 24 c8 00 00 	mov    0xc8(%r12),%rax
  40bac5:	00 
  40bac6:	48 89 84 24 b0 00 00 	mov    %rax,0xb0(%rsp)
  40bacd:	00 
    int8_t *const befs_positions_by_rank =
  40bace:	49 8d 47 60          	lea    0x60(%r15),%rax
  40bad2:	48 89 84 24 c0 00 00 	mov    %rax,0xc0(%rsp)
  40bad9:	00 
    while (PTR_STATE != NULL)
  40bada:	4d 85 f6             	test   %r14,%r14
  40badd:	0f 84 1d 09 00 00    	je     40c400 <resume_solution+0x2110>
    pri_queue *pqueue = NULL;
  40bae3:	48 c7 84 24 c8 00 00 	movq   $0x0,0xc8(%rsp)
  40baea:	00 00 00 00 00 
  40baef:	e9 04 f4 ff ff       	jmpq   40aef8 <resume_solution+0xc08>
  40baf4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40bafb:	00 00 00 00 
  40baff:	90                   	nop
  40bb00:	41 0f b6 56 56       	movzbl 0x56(%r14),%edx
  40bb05:	e9 6b f4 ff ff       	jmpq   40af75 <resume_solution+0xc85>
  40bb0a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
    const_AUTO(new_dfs_max_depth,
  40bb10:	49 8b 47 28          	mov    0x28(%r15),%rax
    DFS_VAR(soft_thread, depth) = 0;
  40bb14:	49 c7 47 38 00 00 00 	movq   $0x0,0x38(%r15)
  40bb1b:	00 
    [0].state = FCS_STATE_keyval_pair_to_collectible(&instance->state_copy);
  40bb1c:	49 81 c4 50 05 00 00 	add    $0x550,%r12
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40bb23:	49 8b 7f 30          	mov    0x30(%r15),%rdi
    const_AUTO(new_dfs_max_depth,
  40bb27:	48 8d 58 40          	lea    0x40(%rax),%rbx
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40bb2b:	48 69 f3 b0 00 00 00 	imul   $0xb0,%rbx,%rsi
  40bb32:	e8 39 56 ff ff       	callq  401170 <realloc@plt>
    memset(DFS_VAR(soft_thread, soft_dfs_info) +
  40bb37:	31 f6                	xor    %esi,%esi
  40bb39:	ba 00 2c 00 00       	mov    $0x2c00,%edx
  40bb3e:	49 69 7f 28 b0 00 00 	imul   $0xb0,0x28(%r15),%rdi
  40bb45:	00 
    DFS_VAR(soft_thread, soft_dfs_info) =
  40bb46:	49 89 47 30          	mov    %rax,0x30(%r15)
    memset(DFS_VAR(soft_thread, soft_dfs_info) +
  40bb4a:	48 01 c7             	add    %rax,%rdi
  40bb4d:	e8 4e 55 ff ff       	callq  4010a0 <memset@plt>
    [0].state = FCS_STATE_keyval_pair_to_collectible(&instance->state_copy);
  40bb52:	49 8b 47 30          	mov    0x30(%r15),%rax
    DFS_VAR(soft_thread, dfs_max_depth) = new_dfs_max_depth;
  40bb56:	49 89 5f 28          	mov    %rbx,0x28(%r15)
    if (!DFS_VAR(soft_thread, moves_by_depth).by_depth_units)
  40bb5a:	49 83 7f 58 00       	cmpq   $0x0,0x58(%r15)
    [0].state = FCS_STATE_keyval_pair_to_collectible(&instance->state_copy);
  40bb5f:	4c 89 20             	mov    %r12,(%rax)
    *my_rand = (long)seed;
  40bb62:	41 8b 47 48          	mov    0x48(%r15),%eax
  40bb66:	49 89 47 40          	mov    %rax,0x40(%r15)
    if (!DFS_VAR(soft_thread, moves_by_depth).by_depth_units)
  40bb6a:	0f 84 e0 08 00 00    	je     40c450 <resume_solution+0x2160>
    if (soft_thread->is_befs)
  40bb70:	41 80 bf f2 01 00 00 	cmpb   $0x0,0x1f2(%r15)
  40bb77:	00 
  40bb78:	49 8b 1f             	mov    (%r15),%rbx
  40bb7b:	0f 84 1f 02 00 00    	je     40bda0 <resume_solution+0x1ab0>
    pq->elems = SMALLOC(pq->elems, (pq->max_size = 1024) + 1);
  40bb81:	c5 f9 6f 3d a7 59 00 	vmovdqa 0x59a7(%rip),%xmm7        # 411530 <fc_solve_is_parent_buf+0xf70>
  40bb88:	00 
  40bb89:	bf 10 40 00 00       	mov    $0x4010,%edi
  40bb8e:	c4 c1 78 11 bf f0 00 	vmovups %xmm7,0xf0(%r15)
  40bb95:	00 00 
  40bb97:	e8 54 55 ff ff       	callq  4010f0 <malloc@plt>
        sum += befs_weights[i];
  40bb9c:	c5 e9 57 d2          	vxorpd %xmm2,%xmm2,%xmm2
  40bba0:	c4 c1 7b 10 8f a8 01 	vmovsd 0x1a8(%r15),%xmm1
  40bba7:	00 00 
  40bba9:	c4 c1 7b 10 a7 b0 01 	vmovsd 0x1b0(%r15),%xmm4
  40bbb0:	00 00 
  40bbb2:	49 89 87 00 01 00 00 	mov    %rax,0x100(%r15)
  40bbb9:	c5 73 58 ca          	vaddsd %xmm2,%xmm1,%xmm9
  40bbbd:	c4 c1 7b 10 af b8 01 	vmovsd 0x1b8(%r15),%xmm5
  40bbc4:	00 00 
  40bbc6:	c4 c1 7b 10 9f c0 01 	vmovsd 0x1c0(%r15),%xmm3
  40bbcd:	00 00 
  40bbcf:	c4 41 7b 10 87 c8 01 	vmovsd 0x1c8(%r15),%xmm8
  40bbd6:	00 00 
  40bbd8:	c5 33 58 cc          	vaddsd %xmm4,%xmm9,%xmm9
    if (sum < 1e-6)
  40bbdc:	c5 fb 10 05 0c 59 00 	vmovsd 0x590c(%rip),%xmm0        # 4114f0 <fc_solve_is_parent_buf+0xf30>
  40bbe3:	00 
        sum += befs_weights[i];
  40bbe4:	c4 c1 7b 10 bf d0 01 	vmovsd 0x1d0(%r15),%xmm7
  40bbeb:	00 00 
    if (sum < 1e-6)
  40bbed:	c5 fb 10 35 f3 58 00 	vmovsd 0x58f3(%rip),%xmm6        # 4114e8 <fc_solve_is_parent_buf+0xf28>
  40bbf4:	00 
        sum += befs_weights[i];
  40bbf5:	c5 33 58 cd          	vaddsd %xmm5,%xmm9,%xmm9
  40bbf9:	c5 33 58 cb          	vaddsd %xmm3,%xmm9,%xmm9
  40bbfd:	c4 41 33 58 c8       	vaddsd %xmm8,%xmm9,%xmm9
  40bc02:	c5 33 58 cf          	vaddsd %xmm7,%xmm9,%xmm9
    if (sum < 1e-6)
  40bc06:	c4 c1 79 2f c1       	vcomisd %xmm9,%xmm0
  40bc0b:	77 05                	ja     40bc12 <resume_solution+0x1922>
  40bc0d:	c4 c1 4b 5e f1       	vdivsd %xmm9,%xmm6,%xmm6
        W(FCS_BEFS_WEIGHT_CARDS_OUT) / (LOCAL_DECKS_NUM * 52);
  40bc12:	c5 f3 59 ce          	vmulsd %xmm6,%xmm1,%xmm1
    const double num_cards_out_factor =
  40bc16:	c5 7b 10 0d da 58 00 	vmovsd 0x58da(%rip),%xmm9        # 4114f8 <fc_solve_is_parent_buf+0xf38>
  40bc1d:	00 
        (weighting->max_sequence_move_factor ||
  40bc1e:	b9 01 00 00 00       	mov    $0x1,%ecx
        num_cards_out_lookup_table[i] = out_sum;
  40bc23:	49 c7 87 38 01 00 00 	movq   $0x0,0x138(%r15)
  40bc2a:	00 00 00 00 
        W(FCS_BEFS_WEIGHT_MAX_SEQUENCE_MOVE) /
  40bc2e:	c5 db 59 e6          	vmulsd %xmm6,%xmm4,%xmm4
        W(FCS_BEFS_WEIGHT_CARDS_UNDER_SEQUENCES) /
  40bc32:	c5 d3 59 ee          	vmulsd %xmm6,%xmm5,%xmm5
        W(FCS_BEFS_WEIGHT_MAX_SEQUENCE_MOVE) /
  40bc36:	c5 db 5e 25 c2 58 00 	vdivsd 0x58c2(%rip),%xmm4,%xmm4        # 411500 <fc_solve_is_parent_buf+0xf40>
  40bc3d:	00 
    weighting->max_sequence_move_factor =
  40bc3e:	c4 c1 7b 11 a7 10 01 	vmovsd %xmm4,0x110(%r15)
  40bc45:	00 00 
        W(FCS_BEFS_WEIGHT_SEQS_OVER_RENEGADE_CARDS) /
  40bc47:	c5 e3 59 de          	vmulsd %xmm6,%xmm3,%xmm3
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40bc4b:	c5 3b 59 c6          	vmulsd %xmm6,%xmm8,%xmm8
        W(FCS_BEFS_WEIGHT_SEQS_OVER_RENEGADE_CARDS) /
  40bc4f:	c5 e3 5e 1d b1 58 00 	vdivsd 0x58b1(%rip),%xmm3,%xmm3        # 411508 <fc_solve_is_parent_buf+0xf48>
  40bc56:	00 
        W(FCS_BEFS_WEIGHT_NUM_CARDS_NOT_ON_PARENTS) / (LOCAL_DECKS_NUM * 52);
  40bc57:	c5 c3 59 f6          	vmulsd %xmm6,%xmm7,%xmm6
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40bc5b:	c5 3b 5e 05 ad 58 00 	vdivsd 0x58ad(%rip),%xmm8,%xmm8        # 411510 <fc_solve_is_parent_buf+0xf50>
  40bc62:	00 
    const double num_cards_out_factor =
  40bc63:	c4 c1 73 5e c9       	vdivsd %xmm9,%xmm1,%xmm1
        W(FCS_BEFS_WEIGHT_NUM_CARDS_NOT_ON_PARENTS) / (LOCAL_DECKS_NUM * 52);
  40bc68:	c4 41 4b 5e c9       	vdivsd %xmm9,%xmm6,%xmm9
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bc6d:	c5 f3 58 c2          	vaddsd %xmm2,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bc71:	c4 c1 7b 11 87 40 01 	vmovsd %xmm0,0x140(%r15)
  40bc78:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bc7a:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bc7e:	c4 c1 7b 11 87 48 01 	vmovsd %xmm0,0x148(%r15)
  40bc85:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bc87:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bc8b:	c4 c1 7b 11 87 50 01 	vmovsd %xmm0,0x150(%r15)
  40bc92:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bc94:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bc98:	c4 c1 7b 11 87 58 01 	vmovsd %xmm0,0x158(%r15)
  40bc9f:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bca1:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bca5:	c4 c1 7b 11 87 60 01 	vmovsd %xmm0,0x160(%r15)
  40bcac:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bcae:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bcb2:	c4 c1 7b 11 87 68 01 	vmovsd %xmm0,0x168(%r15)
  40bcb9:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bcbb:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bcbf:	c4 c1 7b 11 87 70 01 	vmovsd %xmm0,0x170(%r15)
  40bcc6:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bcc8:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bccc:	c4 c1 7b 11 87 78 01 	vmovsd %xmm0,0x178(%r15)
  40bcd3:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bcd5:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bcd9:	c4 c1 7b 11 87 80 01 	vmovsd %xmm0,0x180(%r15)
  40bce0:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bce2:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bce6:	c4 c1 7b 11 87 88 01 	vmovsd %xmm0,0x188(%r15)
  40bced:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bcef:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bcf3:	c4 c1 7b 11 87 90 01 	vmovsd %xmm0,0x190(%r15)
  40bcfa:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bcfc:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bd00:	c4 c1 7b 11 87 98 01 	vmovsd %xmm0,0x198(%r15)
  40bd07:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bd09:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40bd0d:	c4 c1 7b 11 87 a0 01 	vmovsd %xmm0,0x1a0(%r15)
  40bd14:	00 00 
        W(FCS_BEFS_WEIGHT_CARDS_UNDER_SEQUENCES) /
  40bd16:	c5 d3 5e 6b 08       	vdivsd 0x8(%rbx),%xmm5,%xmm5
        (weighting->max_sequence_move_factor ||
  40bd1b:	c5 f9 2e ea          	vucomisd %xmm2,%xmm5
    weighting->cards_under_sequences_factor =
  40bd1f:	c4 c1 7b 11 af 18 01 	vmovsd %xmm5,0x118(%r15)
  40bd26:	00 00 
    weighting->seqs_over_renegade_cards_factor =
  40bd28:	c4 c1 7b 11 9f 20 01 	vmovsd %xmm3,0x120(%r15)
  40bd2f:	00 00 
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40bd31:	c4 41 7b 11 87 28 01 	vmovsd %xmm8,0x128(%r15)
  40bd38:	00 00 
        (weighting->max_sequence_move_factor ||
  40bd3a:	0f 9a c0             	setp   %al
  40bd3d:	0f 45 c1             	cmovne %ecx,%eax
            weighting->cards_under_sequences_factor ||
  40bd40:	c5 f9 2e e2          	vucomisd %xmm2,%xmm4
    weighting->num_cards_not_on_parents_factor =
  40bd44:	c4 41 7b 11 8f 30 01 	vmovsd %xmm9,0x130(%r15)
  40bd4b:	00 00 
            weighting->cards_under_sequences_factor ||
  40bd4d:	0f 9a c2             	setp   %dl
  40bd50:	0f 45 d1             	cmovne %ecx,%edx
    weighting->should_go_over_stacks =
  40bd53:	09 d0                	or     %edx,%eax
            weighting->cards_under_sequences_factor ||
  40bd55:	c5 f9 2e da          	vucomisd %xmm2,%xmm3
  40bd59:	0f 9a c2             	setp   %dl
  40bd5c:	0f 45 d1             	cmovne %ecx,%edx
    weighting->should_go_over_stacks =
  40bd5f:	09 d0                	or     %edx,%eax
  40bd61:	41 88 87 08 01 00 00 	mov    %al,0x108(%r15)
    if (!BEFS_M_VAR(soft_thread, moves_list))
  40bd68:	49 8b 87 c8 00 00 00 	mov    0xc8(%r15),%rax
  40bd6f:	48 85 c0             	test   %rax,%rax
  40bd72:	0f 84 ae 00 00 00    	je     40be26 <resume_solution+0x1b36>
        FCS_STATE_keyval_pair_to_collectible(
  40bd78:	4d 8b 27             	mov    (%r15),%r12
            STRUCT_TURN_ON_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED);
  40bd7b:	41 c6 87 e1 01 00 00 	movb   $0x1,0x1e1(%r15)
  40bd82:	01 
  40bd83:	49 8d 84 24 50 05 00 	lea    0x550(%r12),%rax
  40bd8a:	00 
    BEFS_M_VAR(soft_thread, first_state_to_check) =
  40bd8b:	49 89 87 d8 01 00 00 	mov    %rax,0x1d8(%r15)
  40bd92:	e9 35 e7 ff ff       	jmpq   40a4cc <resume_solution+0x1dc>
  40bd97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40bd9e:	00 00 
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  40bda0:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
  40bda7:	4c 8b a3 e8 00 00 00 	mov    0xe8(%rbx),%r12
  40bdae:	48 89 c2             	mov    %rax,%rdx
  40bdb1:	4c 29 e2             	sub    %r12,%rdx
  40bdb4:	48 83 fa 0f          	cmp    $0xf,%rdx
  40bdb8:	0f 86 32 0b 00 00    	jbe    40c8f0 <resume_solution+0x2600>
        allocator->rollback_ptr = allocator->ptr;
  40bdbe:	4c 89 a3 f0 00 00 00 	mov    %r12,0xf0(%rbx)
    allocator->ptr += how_much;
  40bdc5:	49 8d 54 24 10       	lea    0x10(%r12),%rdx
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  40bdca:	48 29 d0             	sub    %rdx,%rax
    allocator->ptr += how_much;
  40bdcd:	48 89 93 e8 00 00 00 	mov    %rdx,0xe8(%rbx)
    my_brfs_queue = NEW_BRFS_QUEUE_ITEM();
  40bdd4:	4d 89 a7 d8 00 00 00 	mov    %r12,0xd8(%r15)
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  40bddb:	48 83 f8 0f          	cmp    $0xf,%rax
  40bddf:	0f 86 bb 0a 00 00    	jbe    40c8a0 <resume_solution+0x25b0>
        allocator->rollback_ptr = allocator->ptr;
  40bde5:	48 89 93 f0 00 00 00 	mov    %rdx,0xf0(%rbx)
    allocator->ptr += how_much;
  40bdec:	48 8d 42 10          	lea    0x10(%rdx),%rax
  40bdf0:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
    if (!BEFS_M_VAR(soft_thread, moves_list))
  40bdf7:	49 8b 87 c8 00 00 00 	mov    0xc8(%r15),%rax
    my_brfs_queue_last_item = my_brfs_queue->next = NEW_BRFS_QUEUE_ITEM();
  40bdfe:	49 89 54 24 08       	mov    %rdx,0x8(%r12)
  40be03:	49 89 97 e0 00 00 00 	mov    %rdx,0xe0(%r15)
    my_brfs_queue_last_item->next = NULL;
  40be0a:	48 c7 42 08 00 00 00 	movq   $0x0,0x8(%rdx)
  40be11:	00 
    my_brfs_recycle_bin = NULL;
  40be12:	49 c7 87 e8 00 00 00 	movq   $0x0,0xe8(%r15)
  40be19:	00 00 00 00 
    if (!BEFS_M_VAR(soft_thread, moves_list))
  40be1d:	48 85 c0             	test   %rax,%rax
  40be20:	0f 85 52 ff ff ff    	jne    40bd78 <resume_solution+0x1a88>
             group_idx < soft_thread->by_depth_moves_order.by_depth_moves[0]
  40be26:	49 8b 4f 18          	mov    0x18(%r15),%rcx
        for (size_t group_idx = 0;
  40be2a:	48 83 79 08 00       	cmpq   $0x0,0x8(%rcx)
  40be2f:	0f 84 2b 0b 00 00    	je     40c960 <resume_solution+0x2670>
        size_t num = 0;
  40be35:	45 31 ed             	xor    %r13d,%r13d
        for (size_t group_idx = 0;
  40be38:	31 db                	xor    %ebx,%ebx
  40be3a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                    .moves_order.groups[group_idx]
  40be40:	48 69 d3 e8 00 00 00 	imul   $0xe8,%rbx,%rdx
    fcs_move_func **const out_move_funcs_list, size_t *const num_so_far,
    const fcs_move_func *const indexes, const size_t count_to_add)
{
    size_t num = *num_so_far;
    fcs_move_func *const move_funcs_list =
        SREALLOC(*out_move_funcs_list, num + count_to_add);
  40be47:	48 89 c7             	mov    %rax,%rdi
  40be4a:	48 03 51 10          	add    0x10(%rcx),%rdx
            add_to_move_funcs_list(&moves_list, &num,
  40be4e:	4c 8b 72 08          	mov    0x8(%rdx),%r14
                    .move_funcs,
  40be52:	4c 8b 02             	mov    (%rdx),%r8
  40be55:	4f 8d 24 2e          	lea    (%r14,%r13,1),%r12
  40be59:	4a 8d 34 e5 00 00 00 	lea    0x0(,%r12,8),%rsi
  40be60:	00 
  40be61:	4c 89 84 24 d0 00 00 	mov    %r8,0xd0(%rsp)
  40be68:	00 
  40be69:	e8 02 53 ff ff       	callq  401170 <realloc@plt>
    for (size_t i = 0; i < count_to_add; ++i)
  40be6e:	4d 85 f6             	test   %r14,%r14
  40be71:	0f 84 99 05 00 00    	je     40c410 <resume_solution+0x2120>
  40be77:	4c 8b 84 24 d0 00 00 	mov    0xd0(%rsp),%r8
  40be7e:	00 
  40be7f:	4a 8d 0c e8          	lea    (%rax,%r13,8),%rcx
  40be83:	31 d2                	xor    %edx,%edx
  40be85:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40be8c:	00 00 00 00 
    {
        move_funcs_list[num++].f = fc_solve_sfs_move_funcs[indexes[i].idx];
  40be90:	49 8b 34 d0          	mov    (%r8,%rdx,8),%rsi
  40be94:	48 8b 34 f5 c0 fc 40 	mov    0x40fcc0(,%rsi,8),%rsi
  40be9b:	00 
  40be9c:	48 89 34 d1          	mov    %rsi,(%rcx,%rdx,8)
    for (size_t i = 0; i < count_to_add; ++i)
  40bea0:	48 83 c2 01          	add    $0x1,%rdx
  40bea4:	49 39 d6             	cmp    %rdx,%r14
  40bea7:	75 e7                	jne    40be90 <resume_solution+0x1ba0>
             group_idx < soft_thread->by_depth_moves_order.by_depth_moves[0]
  40bea9:	49 8b 4f 18          	mov    0x18(%r15),%rcx
             ++group_idx)
  40bead:	48 83 c3 01          	add    $0x1,%rbx
  40beb1:	4d 89 e5             	mov    %r12,%r13
        for (size_t group_idx = 0;
  40beb4:	48 3b 59 08          	cmp    0x8(%rcx),%rbx
  40beb8:	72 86                	jb     40be40 <resume_solution+0x1b50>
  40beba:	4a 8d 14 e0          	lea    (%rax,%r12,8),%rdx
        BEFS_M_VAR(soft_thread, moves_list) = moves_list;
  40bebe:	c4 e1 f9 6e e0       	vmovq  %rax,%xmm4
  40bec3:	c4 e3 d9 22 c2 01    	vpinsrq $0x1,%rdx,%xmm4,%xmm0
  40bec9:	c4 c1 78 11 87 c8 00 	vmovups %xmm0,0xc8(%r15)
  40bed0:	00 00 
  40bed2:	e9 a1 fe ff ff       	jmpq   40bd78 <resume_solution+0x1a88>
  40bed7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40bede:	00 00 
    if (HT_FIELD(hard_thread, prelude_idx) < prelude_num_items)
  40bee0:	48 8b 9c 24 e8 00 00 	mov    0xe8(%rsp),%rbx
  40bee7:	00 
  40bee8:	48 8b b3 08 05 00 00 	mov    0x508(%rbx),%rsi
  40beef:	48 8b 3b             	mov    (%rbx),%rdi
  40bef2:	48 39 74 24 58       	cmp    %rsi,0x58(%rsp)
  40bef7:	0f 86 b3 04 00 00    	jbe    40c3b0 <resume_solution+0x20c0>
        prelude[HT_FIELD(hard_thread, prelude_idx)++];
  40befd:	48 8d 46 01          	lea    0x1(%rsi),%rax
  40bf01:	48 c1 e6 04          	shl    $0x4,%rsi
  40bf05:	48 03 74 24 50       	add    0x50(%rsp),%rsi
  40bf0a:	48 89 83 08 05 00 00 	mov    %rax,0x508(%rbx)
    set_next_soft_thread(
  40bf11:	48 8b 46 08          	mov    0x8(%rsi),%rax
    (*st_idx_ptr) = scan_idx;
  40bf15:	48 8b 16             	mov    (%rsi),%rdx
        NUM_CHECKED_STATES + quota;
  40bf18:	48 01 f8             	add    %rdi,%rax
    (*st_idx_ptr) = scan_idx;
  40bf1b:	48 89 93 d0 00 00 00 	mov    %rdx,0xd0(%rbx)
        NUM_CHECKED_STATES + quota;
  40bf22:	48 89 83 c8 00 00 00 	mov    %rax,0xc8(%rbx)
  40bf29:	e9 52 e5 ff ff       	jmpq   40a480 <resume_solution+0x190>
  40bf2e:	66 90                	xchg   %ax,%ax
        if (fcs_freecell_is_empty(*state_ptr, i))
  40bf30:	41 80 7c 24 40 00    	cmpb   $0x0,0x40(%r12)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40bf36:	49 8b 04 24          	mov    (%r12),%rax
  40bf3a:	49 8b 4c 24 08       	mov    0x8(%r12),%rcx
        if (fcs_freecell_is_empty(*state_ptr, i))
  40bf3f:	0f 94 c2             	sete   %dl
            num_vacant_freecells++;
  40bf42:	41 80 7c 24 41 01    	cmpb   $0x1,0x41(%r12)
  40bf48:	80 d2 00             	adc    $0x0,%dl
  40bf4b:	41 80 7c 24 42 01    	cmpb   $0x1,0x42(%r12)
  40bf51:	80 d2 00             	adc    $0x0,%dl
  40bf54:	41 80 7c 24 43 01    	cmpb   $0x1,0x43(%r12)
  40bf5a:	80 d2 00             	adc    $0x0,%dl
        if (fcs_state_col_is_empty(*state_ptr, i))
  40bf5d:	80 38 00             	cmpb   $0x0,(%rax)
  40bf60:	0f 94 c0             	sete   %al
            ++num_vacant_stacks;
  40bf63:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40bf66:	49 8b 4c 24 10       	mov    0x10(%r12),%rcx
            ++num_vacant_stacks;
  40bf6b:	14 00                	adc    $0x0,%al
  40bf6d:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40bf70:	49 8b 4c 24 18       	mov    0x18(%r12),%rcx
            ++num_vacant_stacks;
  40bf75:	14 00                	adc    $0x0,%al
  40bf77:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40bf7a:	49 8b 4c 24 20       	mov    0x20(%r12),%rcx
            ++num_vacant_stacks;
  40bf7f:	14 00                	adc    $0x0,%al
  40bf81:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40bf84:	49 8b 4c 24 28       	mov    0x28(%r12),%rcx
            ++num_vacant_stacks;
  40bf89:	14 00                	adc    $0x0,%al
  40bf8b:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40bf8e:	49 8b 4c 24 30       	mov    0x30(%r12),%rcx
            ++num_vacant_stacks;
  40bf93:	14 00                	adc    $0x0,%al
  40bf95:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40bf98:	49 8b 4c 24 38       	mov    0x38(%r12),%rcx
            ++num_vacant_stacks;
  40bf9d:	14 00                	adc    $0x0,%al
        if (fcs_state_col_is_empty(*state_ptr, i))
  40bf9f:	80 39 00             	cmpb   $0x0,(%rcx)
  40bfa2:	75 1c                	jne    40bfc0 <resume_solution+0x1cd0>
            ++num_vacant_stacks;
  40bfa4:	83 c0 01             	add    $0x1,%eax
                    if (unlikely((num_vacant_stacks == LOCAL_STACKS_NUM) &&
  40bfa7:	3c 08                	cmp    $0x8,%al
  40bfa9:	75 15                	jne    40bfc0 <resume_solution+0x1cd0>
  40bfab:	80 fa 04             	cmp    $0x4,%dl
  40bfae:	0f 84 dc 00 00 00    	je     40c090 <resume_solution+0x1da0>
  40bfb4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40bfbb:	00 00 00 00 
  40bfbf:	90                   	nop
                        the_soft_dfs_info->num_vacant_freecells =
  40bfc0:	88 93 a9 00 00 00    	mov    %dl,0xa9(%rbx)
    memset(positions_by_rank, -1, sizeof(fcs__positions_by_rank));
  40bfc6:	c5 f9 76 c0          	vpcmpeqd %xmm0,%xmm0,%xmm0
  40bfca:	31 c9                	xor    %ecx,%ecx
                    soft_thread->num_vacant_freecells =
  40bfcc:	41 88 95 e4 01 00 00 	mov    %dl,0x1e4(%r13)
                        the_soft_dfs_info->num_vacant_stacks =
  40bfd3:	88 83 a8 00 00 00    	mov    %al,0xa8(%rbx)
                    soft_thread->num_vacant_stacks =
  40bfd9:	41 88 85 e3 01 00 00 	mov    %al,0x1e3(%r13)
                        (the_soft_dfs_info->positions_by_rank)
  40bfe0:	48 8d 43 40          	lea    0x40(%rbx),%rax
  40bfe4:	c5 f8 11 43 40       	vmovups %xmm0,0x40(%rbx)
  40bfe9:	c5 f8 11 40 10       	vmovups %xmm0,0x10(%rax)
  40bfee:	c5 f8 11 40 20       	vmovups %xmm0,0x20(%rax)
  40bff3:	c5 f8 11 40 30       	vmovups %xmm0,0x30(%rax)
  40bff8:	c5 f8 11 40 40       	vmovups %xmm0,0x40(%rax)
  40bffd:	c5 f8 11 40 50       	vmovups %xmm0,0x50(%rax)
  40c002:	48 c7 40 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rax)
  40c009:	ff 
        for (int ds = 0; ds < LOCAL_STACKS_NUM; ds++)
  40c00a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            const_AUTO(dest_col, fcs_state_get_col(state_key, ds));
  40c010:	4d 8b 0c cc          	mov    (%r12,%rcx,8),%r9
            int top_card_idx = fcs_col_len(dest_col);
  40c014:	41 0f be 11          	movsbl (%r9),%edx
            if (unlikely((top_card_idx--) == 0))
  40c018:	8d 72 ff             	lea    -0x1(%rdx),%esi
  40c01b:	85 d2                	test   %edx,%edx
  40c01d:	74 5c                	je     40c07b <resume_solution+0x1d8b>
                dest_card = fcs_col_get_card(dest_col, 0);
  40c01f:	41 0f be 51 01       	movsbl 0x1(%r9),%edx
                for (int dc = 0; dc < top_card_idx;
  40c024:	89 cf                	mov    %ecx,%edi
  40c026:	85 f6                	test   %esi,%esi
  40c028:	7e 40                	jle    40c06a <resume_solution+0x1d7a>
  40c02a:	45 31 c0             	xor    %r8d,%r8d
  40c02d:	0f 1f 00             	nopl   (%rax)
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40c030:	4f 0f be 74 01 02    	movsbq 0x2(%r9,%r8,1),%r14
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40c036:	4c 0f be d2          	movsbq %dl,%r10
  40c03a:	49 c1 e2 06          	shl    $0x6,%r10
                    if (!fcs_is_parent_card(dest_below_card, dest_card))
  40c03e:	43 80 bc 16 c0 05 41 	cmpb   $0x0,0x4105c0(%r14,%r10,1)
  40c045:	00 00 
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40c047:	4d 89 f3             	mov    %r14,%r11
                    if (!fcs_is_parent_card(dest_below_card, dest_card))
  40c04a:	75 11                	jne    40c05d <resume_solution+0x1d6d>
    int8_t *ptr = &positions_by_rank[(dest_card - 4) << 1];
  40c04c:	8d 54 12 f8          	lea    -0x8(%rdx,%rdx,1),%edx
  40c050:	48 63 d2             	movslq %edx,%rdx
  40c053:	48 01 c2             	add    %rax,%rdx
    *(ptr++) = dest_stack;
  40c056:	40 88 3a             	mov    %dil,(%rdx)
                        fc_solve__assign_dest_stack_and_col_ptr(
  40c059:	44 88 42 01          	mov    %r8b,0x1(%rdx)
  40c05d:	49 83 c0 01          	add    $0x1,%r8
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40c061:	41 0f be d3          	movsbl %r11b,%edx
                for (int dc = 0; dc < top_card_idx;
  40c065:	44 39 c6             	cmp    %r8d,%esi
  40c068:	7f c6                	jg     40c030 <resume_solution+0x1d40>
    int8_t *ptr = &positions_by_rank[(dest_card - 4) << 1];
  40c06a:	8d 54 12 f8          	lea    -0x8(%rdx,%rdx,1),%edx
  40c06e:	48 63 d2             	movslq %edx,%rdx
  40c071:	48 01 c2             	add    %rax,%rdx
    *(ptr++) = dest_stack;
  40c074:	40 88 3a             	mov    %dil,(%rdx)
            fc_solve__assign_dest_stack_and_col_ptr(
  40c077:	40 88 72 01          	mov    %sil,0x1(%rdx)
  40c07b:	48 83 c1 01          	add    $0x1,%rcx
        for (int ds = 0; ds < LOCAL_STACKS_NUM; ds++)
  40c07f:	48 83 f9 08          	cmp    $0x8,%rcx
  40c083:	75 8b                	jne    40c010 <resume_solution+0x1d20>
  40c085:	4c 8b 73 18          	mov    0x18(%rbx),%r14
  40c089:	e9 66 e6 ff ff       	jmpq   40a6f4 <resume_solution+0x404>
  40c08e:	66 90                	xchg   %ax,%ax
  40c090:	4c 8b a4 24 90 00 00 	mov    0x90(%rsp),%r12
  40c097:	00 
                        BUMP_NUM_CHECKED_STATES();
  40c098:	4d 89 ef             	mov    %r13,%r15
                        return FCS_STATE_WAS_SOLVED;
  40c09b:	31 db                	xor    %ebx,%ebx
                        BUMP_NUM_CHECKED_STATES();
  40c09d:	45 31 ed             	xor    %r13d,%r13d
  40c0a0:	49 83 04 24 01       	addq   $0x1,(%r12)
                        return FCS_STATE_WAS_SOLVED;
  40c0a5:	e9 86 ef ff ff       	jmpq   40b030 <resume_solution+0xd40>
  40c0aa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                                ->derived_states_random_indexes_max_size = 1;
  40c0b0:	48 c7 43 30 01 00 00 	movq   $0x1,0x30(%rbx)
  40c0b7:	00 
                                ->derived_states_random_indexes = SREALLOC(
  40c0b8:	be 08 00 00 00       	mov    $0x8,%esi
  40c0bd:	48 89 c7             	mov    %rax,%rdi
  40c0c0:	e8 ab 50 ff ff       	callq  401170 <realloc@plt>
  40c0c5:	48 89 43 38          	mov    %rax,0x38(%rbx)
  40c0c9:	e9 1c e6 ff ff       	jmpq   40a6ea <resume_solution+0x3fa>
  40c0ce:	66 90                	xchg   %ax,%ax
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  40c0d0:	48 83 c6 10          	add    $0x10,%rsi
  40c0d4:	48 89 c7             	mov    %rax,%rdi
  40c0d7:	48 c1 e6 04          	shl    $0x4,%rsi
  40c0db:	e8 90 50 ff ff       	callq  401170 <realloc@plt>
  40c0e0:	48 8b bc 24 00 01 00 	mov    0x100(%rsp),%rdi
  40c0e7:	00 
        list->states =
  40c0e8:	48 89 84 24 08 01 00 	mov    %rax,0x108(%rsp)
  40c0ef:	00 
  40c0f0:	e9 c8 e5 ff ff       	jmpq   40a6bd <resume_solution+0x3cd>
  40c0f5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c0fc:	00 00 00 00 
                    the_soft_dfs_info->derived_states_list = derived_list;
  40c100:	c5 f9 6f 9c 24 00 01 	vmovdqa 0x100(%rsp),%xmm3
  40c107:	00 00 
  40c109:	4d 89 ef             	mov    %r13,%r15
  40c10c:	41 bd 05 00 00 00    	mov    $0x5,%r13d
  40c112:	c5 f8 11 9b b8 00 00 	vmovups %xmm3,0xb8(%rbx)
  40c119:	00 
                    return FCS_STATE_SUSPEND_PROCESS;
  40c11a:	bb 05 00 00 00       	mov    $0x5,%ebx
  40c11f:	e9 0c ef ff ff       	jmpq   40b030 <resume_solution+0xd40>
  40c124:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c12b:	00 00 00 00 
  40c12f:	90                   	nop
                    curr_by_depth_unit++;
  40c130:	48 8b bc 24 d0 00 00 	mov    0xd0(%rsp),%rdi
  40c137:	00 
                    RECALC_BY_DEPTH_LIMITS();
  40c138:	48 c7 84 24 c8 00 00 	movq   $0x0,0xc8(%rsp)
  40c13f:	00 00 00 00 00 
  40c144:	48 8b 77 18          	mov    0x18(%rdi),%rsi
                    curr_by_depth_unit++;
  40c148:	48 8d 4f 18          	lea    0x18(%rdi),%rcx
                    RECALC_BY_DEPTH_LIMITS();
  40c14c:	48 89 b4 24 a0 00 00 	mov    %rsi,0xa0(%rsp)
  40c153:	00 
  40c154:	48 39 8c 24 80 00 00 	cmp    %rcx,0x80(%rsp)
  40c15b:	00 
  40c15c:	74 0b                	je     40c169 <resume_solution+0x1e79>
  40c15e:	48 8b 3f             	mov    (%rdi),%rdi
  40c161:	48 89 bc 24 c8 00 00 	mov    %rdi,0xc8(%rsp)
  40c168:	00 
  40c169:	48 8b bc 24 d0 00 00 	mov    0xd0(%rsp),%rdi
  40c170:	00 
                    curr_by_depth_unit++;
  40c171:	48 89 8c 24 d0 00 00 	mov    %rcx,0xd0(%rsp)
  40c178:	00 
                    RECALC_BY_DEPTH_LIMITS();
  40c179:	48 8b 77 20          	mov    0x20(%rdi),%rsi
  40c17d:	48 8b 7f 28          	mov    0x28(%rdi),%rdi
  40c181:	48 89 b4 24 e0 00 00 	mov    %rsi,0xe0(%rsp)
  40c188:	00 
  40c189:	48 89 bc 24 c0 00 00 	mov    %rdi,0xc0(%rsp)
  40c190:	00 
  40c191:	e9 a1 e6 ff ff       	jmpq   40a837 <resume_solution+0x547>
  40c196:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40c19d:	00 00 00 
                if (is_a_complete_scan)
  40c1a0:	80 7c 24 40 00       	cmpb   $0x0,0x40(%rsp)
  40c1a5:	74 1b                	je     40c1c2 <resume_solution+0x1ed2>
                    FCS_S_VISITED(PTR_STATE) |= FCS_VISITED_ALL_TESTS_DONE;
  40c1a7:	41 0f b6 54 24 56    	movzbl 0x56(%r12),%edx
  40c1ad:	89 d0                	mov    %edx,%eax
  40c1af:	83 c8 08             	or     $0x8,%eax
                    MARK_AS_DEAD_END(PTR_STATE);
  40c1b2:	80 7c 24 47 00       	cmpb   $0x0,0x47(%rsp)
                    FCS_S_VISITED(PTR_STATE) |= FCS_VISITED_ALL_TESTS_DONE;
  40c1b7:	41 88 44 24 56       	mov    %al,0x56(%r12)
                    MARK_AS_DEAD_END(PTR_STATE);
  40c1bc:	0f 85 4e 01 00 00    	jne    40c310 <resume_solution+0x2020>
                the_soft_dfs_info->derived_states_list = derived_list;
  40c1c2:	c5 f9 6f b4 24 00 01 	vmovdqa 0x100(%rsp),%xmm6
  40c1c9:	00 00 
  40c1cb:	c5 f8 11 73 08       	vmovups %xmm6,0x8(%rbx)
                if (unlikely(--DEPTH() < 0))
  40c1d0:	49 8b 45 38          	mov    0x38(%r13),%rax
  40c1d4:	48 83 e8 01          	sub    $0x1,%rax
  40c1d8:	49 89 45 38          	mov    %rax,0x38(%r13)
  40c1dc:	0f 88 ce 00 00 00    	js     40c2b0 <resume_solution+0x1fc0>
                derived_list = the_soft_dfs_info->derived_states_list;
  40c1e2:	c5 fa 6f a3 58 ff ff 	vmovdqu -0xa8(%rbx),%xmm4
  40c1e9:	ff 
                --the_soft_dfs_info;
  40c1ea:	48 8d 8b 50 ff ff ff 	lea    -0xb0(%rbx),%rcx
                derived_list = the_soft_dfs_info->derived_states_list;
  40c1f1:	c5 f8 29 a4 24 00 01 	vmovaps %xmm4,0x100(%rsp)
  40c1f8:	00 00 
                soft_thread->num_vacant_freecells =
  40c1fa:	0f b6 53 f9          	movzbl -0x7(%rbx),%edx
                PTR_STATE = the_soft_dfs_info->state;
  40c1fe:	4c 8b a3 50 ff ff ff 	mov    -0xb0(%rbx),%r12
                soft_thread->num_vacant_freecells =
  40c205:	41 88 95 e4 01 00 00 	mov    %dl,0x1e4(%r13)
                soft_thread->num_vacant_stacks =
  40c20c:	0f b6 53 f8          	movzbl -0x8(%rbx),%edx
                FCS_ASSIGN_STATE_KEY();
  40c210:	49 8d 74 24 48       	lea    0x48(%r12),%rsi
  40c215:	4c 89 a4 24 b8 00 00 	mov    %r12,0xb8(%rsp)
  40c21c:	00 
  40c21d:	48 89 b4 24 b0 00 00 	mov    %rsi,0xb0(%rsp)
  40c224:	00 
                soft_thread->num_vacant_stacks =
  40c225:	41 88 95 e3 01 00 00 	mov    %dl,0x1e3(%r13)
                if (unlikely(DEPTH() < by_depth_min_depth))
  40c22c:	48 3b 84 24 c8 00 00 	cmp    0xc8(%rsp),%rax
  40c233:	00 
  40c234:	0f 8d 8c e6 ff ff    	jge    40a8c6 <resume_solution+0x5d6>
                    curr_by_depth_unit--;
  40c23a:	48 8b bc 24 d0 00 00 	mov    0xd0(%rsp),%rdi
  40c241:	00 
                    RECALC_BY_DEPTH_LIMITS();
  40c242:	48 c7 84 24 c8 00 00 	movq   $0x0,0xc8(%rsp)
  40c249:	00 00 00 00 00 
  40c24e:	48 8b 77 e8          	mov    -0x18(%rdi),%rsi
                    curr_by_depth_unit--;
  40c252:	48 8d 57 e8          	lea    -0x18(%rdi),%rdx
                    RECALC_BY_DEPTH_LIMITS();
  40c256:	48 89 b4 24 a0 00 00 	mov    %rsi,0xa0(%rsp)
  40c25d:	00 
  40c25e:	48 39 94 24 80 00 00 	cmp    %rdx,0x80(%rsp)
  40c265:	00 
  40c266:	74 0c                	je     40c274 <resume_solution+0x1f84>
  40c268:	48 8b 7f d0          	mov    -0x30(%rdi),%rdi
  40c26c:	48 89 bc 24 c8 00 00 	mov    %rdi,0xc8(%rsp)
  40c273:	00 
  40c274:	48 8b b4 24 d0 00 00 	mov    0xd0(%rsp),%rsi
  40c27b:	00 
                    curr_by_depth_unit--;
  40c27c:	48 89 94 24 d0 00 00 	mov    %rdx,0xd0(%rsp)
  40c283:	00 
                    RECALC_BY_DEPTH_LIMITS();
  40c284:	48 8b 7e f0          	mov    -0x10(%rsi),%rdi
  40c288:	48 8b 76 f8          	mov    -0x8(%rsi),%rsi
  40c28c:	48 89 bc 24 e0 00 00 	mov    %rdi,0xe0(%rsp)
  40c293:	00 
  40c294:	48 89 b4 24 c0 00 00 	mov    %rsi,0xc0(%rsp)
  40c29b:	00 
  40c29c:	e9 25 e6 ff ff       	jmpq   40a8c6 <resume_solution+0x5d6>
  40c2a1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c2a8:	00 00 00 00 
  40c2ac:	0f 1f 40 00          	nopl   0x0(%rax)
  40c2b0:	4c 8b a4 24 90 00 00 	mov    0x90(%rsp),%r12
  40c2b7:	00 
    BUMP_NUM_CHECKED_STATES();
  40c2b8:	4d 89 ef             	mov    %r13,%r15
    return FCS_STATE_IS_NOT_SOLVEABLE;
  40c2bb:	bb 01 00 00 00       	mov    $0x1,%ebx
    BUMP_NUM_CHECKED_STATES();
  40c2c0:	49 83 04 24 01       	addq   $0x1,(%r12)
    DEPTH() = -1;
  40c2c5:	49 c7 45 38 ff ff ff 	movq   $0xffffffffffffffff,0x38(%r13)
  40c2cc:	ff 
  40c2cd:	41 bd 01 00 00 00    	mov    $0x1,%r13d
  40c2d3:	e9 58 ed ff ff       	jmpq   40b030 <resume_solution+0xd40>
  40c2d8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40c2df:	00 
  40c2e0:	48 8b bc 24 08 01 00 	mov    0x108(%rsp),%rdi
  40c2e7:	00 
  40c2e8:	48 83 e8 01          	sub    $0x1,%rax
  40c2ec:	48 8d 14 c5 00 00 00 	lea    0x0(,%rax,8),%rdx
  40c2f3:	00 
  40c2f4:	48 89 bc 24 98 00 00 	mov    %rdi,0x98(%rsp)
  40c2fb:	00 
  40c2fc:	48 8b 7b 38          	mov    0x38(%rbx),%rdi
  40c300:	e9 b9 e4 ff ff       	jmpq   40a7be <resume_solution+0x4ce>
  40c305:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c30c:	00 00 00 00 
                    MARK_AS_DEAD_END(PTR_STATE);
  40c310:	49 8b 44 24 48       	mov    0x48(%r12),%rax
    FCS_S_VISITED(temp_state) |= FCS_VISITED_DEAD_END;
  40c315:	83 ca 0c             	or     $0xc,%edx
  40c318:	41 88 54 24 56       	mov    %dl,0x56(%r12)
    if (temp_state != NULL)
  40c31d:	48 85 c0             	test   %rax,%rax
  40c320:	75 2e                	jne    40c350 <resume_solution+0x2060>
  40c322:	e9 9b fe ff ff       	jmpq   40c1c2 <resume_solution+0x1ed2>
  40c327:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40c32e:	00 00 
               (FCS_S_VISITED(temp_state) & FCS_VISITED_ALL_TESTS_DONE))
  40c330:	0f b6 50 56          	movzbl 0x56(%rax),%edx
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40c334:	f6 c2 08             	test   $0x8,%dl
  40c337:	0f 84 85 fe ff ff    	je     40c1c2 <resume_solution+0x1ed2>
            FCS_S_VISITED(temp_state) |= FCS_VISITED_DEAD_END;
  40c33d:	83 ca 04             	or     $0x4,%edx
  40c340:	88 50 56             	mov    %dl,0x56(%rax)
            temp_state = FCS_S_PARENT(temp_state);
  40c343:	48 8b 40 48          	mov    0x48(%rax),%rax
            if (temp_state == NULL)
  40c347:	48 85 c0             	test   %rax,%rax
  40c34a:	0f 84 72 fe ff ff    	je     40c1c2 <resume_solution+0x1ed2>
        --(FCS_S_NUM_ACTIVE_CHILDREN(temp_state));
  40c350:	0f b7 48 54          	movzwl 0x54(%rax),%ecx
  40c354:	8d 51 ff             	lea    -0x1(%rcx),%edx
  40c357:	66 89 50 54          	mov    %dx,0x54(%rax)
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40c35b:	66 85 d2             	test   %dx,%dx
  40c35e:	74 d0                	je     40c330 <resume_solution+0x2040>
  40c360:	e9 5d fe ff ff       	jmpq   40c1c2 <resume_solution+0x1ed2>
  40c365:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c36c:	00 00 00 00 
                &(THE_MOVE_FUNCS_LIST.groups[orig_idx].weighting);
  40c370:	49 69 c6 e8 00 00 00 	imul   $0xe8,%r14,%rax
  40c377:	48 03 84 24 c0 00 00 	add    0xc0(%rsp),%rax
  40c37e:	00 
  40c37f:	48 89 84 24 a8 00 00 	mov    %rax,0xa8(%rsp)
  40c386:	00 
            if (the_soft_dfs_info->move_func_list_idx < THE_MOVE_FUNCS_LIST.num)
  40c387:	4c 3b b4 24 e0 00 00 	cmp    0xe0(%rsp),%r14
  40c38e:	00 
  40c38f:	0f 82 5b e9 ff ff    	jb     40acf0 <resume_solution+0xa00>
            const_AUTO(num_states, derived_list.num_states);
  40c395:	45 31 ff             	xor    %r15d,%r15d
            if (num_states >
  40c398:	48 8b 7b 38          	mov    0x38(%rbx),%rdi
  40c39c:	e9 a2 e3 ff ff       	jmpq   40a743 <resume_solution+0x453>
  40c3a1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c3a8:	00 00 00 00 
  40c3ac:	0f 1f 40 00          	nopl   0x0(%rax)
            ((1 + (*st_idx_ptr)) % num_soft_threads);
  40c3b0:	48 83 c0 01          	add    $0x1,%rax
        set_next_soft_thread(hard_thread, next_st_idx,
  40c3b4:	48 8b 74 24 78       	mov    0x78(%rsp),%rsi
        const int_fast32_t next_st_idx =
  40c3b9:	48 99                	cqto   
  40c3bb:	48 f7 bc 24 88 00 00 	idivq  0x88(%rsp)
  40c3c2:	00 
        set_next_soft_thread(hard_thread, next_st_idx,
  40c3c3:	48 69 c2 f8 01 00 00 	imul   $0x1f8,%rdx,%rax
  40c3ca:	48 8b 84 06 e8 01 00 	mov    0x1e8(%rsi,%rax,1),%rax
  40c3d1:	00 
    (*st_idx_ptr) = scan_idx;
  40c3d2:	48 8b b4 24 e8 00 00 	mov    0xe8(%rsp),%rsi
  40c3d9:	00 
        NUM_CHECKED_STATES + quota;
  40c3da:	48 01 f8             	add    %rdi,%rax
    (*st_idx_ptr) = scan_idx;
  40c3dd:	48 89 96 d0 00 00 00 	mov    %rdx,0xd0(%rsi)
        NUM_CHECKED_STATES + quota;
  40c3e4:	48 89 86 c8 00 00 00 	mov    %rax,0xc8(%rsi)
  40c3eb:	e9 90 e0 ff ff       	jmpq   40a480 <resume_solution+0x190>
  40c3f0:	48 8d 46 10          	lea    0x10(%rsi),%rax
  40c3f4:	e9 6a f5 ff ff       	jmpq   40b963 <resume_solution+0x1673>
  40c3f9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    while (PTR_STATE != NULL)
  40c400:	bb 01 00 00 00       	mov    $0x1,%ebx
    error_code = FCS_STATE_IS_NOT_SOLVEABLE;
  40c405:	41 bd 01 00 00 00    	mov    $0x1,%r13d
  40c40b:	e9 0f f5 ff ff       	jmpq   40b91f <resume_solution+0x162f>
    for (size_t i = 0; i < count_to_add; ++i)
  40c410:	4d 89 ec             	mov    %r13,%r12
  40c413:	e9 91 fa ff ff       	jmpq   40bea9 <resume_solution+0x1bb9>
  40c418:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40c41f:	00 
            BEFS_M_VAR(soft_thread, first_state_to_check) = PTR_STATE;
  40c420:	4d 89 b7 d8 01 00 00 	mov    %r14,0x1d8(%r15)
  40c427:	bb 05 00 00 00       	mov    $0x5,%ebx
            error_code = FCS_STATE_SUSPEND_PROCESS;
  40c42c:	41 bd 05 00 00 00    	mov    $0x5,%r13d
  40c432:	e9 14 f5 ff ff       	jmpq   40b94b <resume_solution+0x165b>
  40c437:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40c43e:	00 00 
            BUMP_NUM_CHECKED_STATES();
  40c440:	48 83 c1 01          	add    $0x1,%rcx
            error_code = FCS_STATE_WAS_SOLVED;
  40c444:	45 31 ed             	xor    %r13d,%r13d
            BUMP_NUM_CHECKED_STATES();
  40c447:	49 89 0c 24          	mov    %rcx,(%r12)
            goto my_return_label;
  40c44b:	e9 fb f4 ff ff       	jmpq   40b94b <resume_solution+0x165b>
        arr_ptr->by_depth_units = SMALLOC(arr_ptr->by_depth_units,
  40c450:	49 8b 5f 10          	mov    0x10(%r15),%rbx
        const_SLOT(master_to_randomize, soft_thread);
  40c454:	41 0f b6 87 f1 01 00 	movzbl 0x1f1(%r15),%eax
  40c45b:	00 
        arr_ptr->by_depth_units = SMALLOC(arr_ptr->by_depth_units,
  40c45c:	4c 8d 24 5b          	lea    (%rbx,%rbx,2),%r12
  40c460:	49 89 5f 50          	mov    %rbx,0x50(%r15)
  40c464:	49 c1 e4 03          	shl    $0x3,%r12
        const_SLOT(master_to_randomize, soft_thread);
  40c468:	88 84 24 a8 00 00 00 	mov    %al,0xa8(%rsp)
        arr_ptr->by_depth_units = SMALLOC(arr_ptr->by_depth_units,
  40c46f:	4c 89 e7             	mov    %r12,%rdi
  40c472:	e8 79 4c ff ff       	callq  4010f0 <malloc@plt>
  40c477:	49 89 c6             	mov    %rax,%r14
  40c47a:	49 89 47 58          	mov    %rax,0x58(%r15)
        const fcs_by_depth_moves_order *const by_depth_moves_order =
  40c47e:	49 8b 47 18          	mov    0x18(%r15),%rax
        for (size_t depth_idx = 0; depth_idx < depth_num; ++depth_idx, ++unit)
  40c482:	48 85 db             	test   %rbx,%rbx
  40c485:	0f 84 e5 f6 ff ff    	je     40bb70 <resume_solution+0x1880>
  40c48b:	49 89 c5             	mov    %rax,%r13
            for (size_t group_idx = 0; group_idx < tests_order_num; ++group_idx)
  40c48e:	4c 89 bc 24 b0 00 00 	mov    %r15,0xb0(%rsp)
  40c495:	00 
  40c496:	4b 8d 04 26          	lea    (%r14,%r12,1),%rax
  40c49a:	48 89 84 24 a0 00 00 	mov    %rax,0xa0(%rsp)
  40c4a1:	00 
  40c4a2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c4a9:	00 00 00 00 
  40c4ad:	0f 1f 00             	nopl   (%rax)
            unit->max_depth = by_depth_moves_order[depth_idx].max_depth;
  40c4b0:	49 8b 45 00          	mov    0x0(%r13),%rax
            fcs_moves_group *const tests_order_groups =
  40c4b4:	4d 8b 65 10          	mov    0x10(%r13),%r12
            unit->max_depth = by_depth_moves_order[depth_idx].max_depth;
  40c4b8:	49 89 06             	mov    %rax,(%r14)
            const_AUTO(tests_order_num,
  40c4bb:	4d 8b 7d 08          	mov    0x8(%r13),%r15
                .groups = SMALLOC(moves_list_of_lists->groups, tests_order_num),
  40c4bf:	49 69 c7 e8 00 00 00 	imul   $0xe8,%r15,%rax
  40c4c6:	48 89 c7             	mov    %rax,%rdi
  40c4c9:	48 89 84 24 d0 00 00 	mov    %rax,0xd0(%rsp)
  40c4d0:	00 
  40c4d1:	e8 1a 4c ff ff       	callq  4010f0 <malloc@plt>
            *moves_list_of_lists = (typeof(*moves_list_of_lists)){
  40c4d6:	49 c7 46 08 00 00 00 	movq   $0x0,0x8(%r14)
  40c4dd:	00 
                .groups = SMALLOC(moves_list_of_lists->groups, tests_order_num),
  40c4de:	49 89 c1             	mov    %rax,%r9
            *moves_list_of_lists = (typeof(*moves_list_of_lists)){
  40c4e1:	49 89 46 10          	mov    %rax,0x10(%r14)
            for (size_t group_idx = 0; group_idx < tests_order_num; ++group_idx)
  40c4e5:	4d 85 ff             	test   %r15,%r15
  40c4e8:	0f 84 52 04 00 00    	je     40c940 <resume_solution+0x2650>
  40c4ee:	45 31 c0             	xor    %r8d,%r8d
  40c4f1:	4c 89 bc 24 e0 00 00 	mov    %r15,0xe0(%rsp)
  40c4f8:	00 
  40c4f9:	4c 89 ea             	mov    %r13,%rdx
  40c4fc:	48 89 c3             	mov    %rax,%rbx
  40c4ff:	49 89 c7             	mov    %rax,%r15
  40c502:	4d 89 c5             	mov    %r8,%r13
  40c505:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c50c:	00 00 00 00 
                add_to_move_funcs_list(&tests_list, &num,
  40c510:	49 8b 74 24 08       	mov    0x8(%r12),%rsi
  40c515:	48 89 94 24 b8 00 00 	mov    %rdx,0xb8(%rsp)
  40c51c:	00 
                    tests_order_groups[group_idx].move_funcs,
  40c51d:	49 8b 0c 24          	mov    (%r12),%rcx
        SREALLOC(*out_move_funcs_list, num + count_to_add);
  40c521:	48 8d 3c f5 00 00 00 	lea    0x0(,%rsi,8),%rdi
  40c528:	00 
  40c529:	48 89 b4 24 c8 00 00 	mov    %rsi,0xc8(%rsp)
  40c530:	00 
  40c531:	48 89 8c 24 c0 00 00 	mov    %rcx,0xc0(%rsp)
  40c538:	00 
  40c539:	e8 b2 4b ff ff       	callq  4010f0 <malloc@plt>
    for (size_t i = 0; i < count_to_add; ++i)
  40c53e:	48 8b b4 24 c8 00 00 	mov    0xc8(%rsp),%rsi
  40c545:	00 
        SREALLOC(*out_move_funcs_list, num + count_to_add);
  40c546:	49 89 c0             	mov    %rax,%r8
    for (size_t i = 0; i < count_to_add; ++i)
  40c549:	48 8b 94 24 b8 00 00 	mov    0xb8(%rsp),%rdx
  40c550:	00 
  40c551:	48 85 f6             	test   %rsi,%rsi
  40c554:	74 24                	je     40c57a <resume_solution+0x228a>
    size_t num = *num_so_far;
  40c556:	48 8b 8c 24 c0 00 00 	mov    0xc0(%rsp),%rcx
  40c55d:	00 
  40c55e:	31 c0                	xor    %eax,%eax
        move_funcs_list[num++].f = fc_solve_sfs_move_funcs[indexes[i].idx];
  40c560:	48 8b 3c c1          	mov    (%rcx,%rax,8),%rdi
  40c564:	48 83 c0 01          	add    $0x1,%rax
  40c568:	48 8b 3c fd c0 fc 40 	mov    0x40fcc0(,%rdi,8),%rdi
  40c56f:	00 
  40c570:	49 89 7c c0 f8       	mov    %rdi,-0x8(%r8,%rax,8)
    for (size_t i = 0; i < count_to_add; ++i)
  40c575:	48 39 c6             	cmp    %rax,%rsi
  40c578:	75 e6                	jne    40c560 <resume_solution+0x2270>
                const_AUTO(tests_list_struct_ptr,
  40c57a:	49 83 c5 01          	add    $0x1,%r13
                            : FCS_NO_SHUFFLING);
  40c57e:	80 bc 24 a8 00 00 00 	cmpb   $0x0,0xa8(%rsp)
  40c585:	00 
                const_AUTO(tests_list_struct_ptr,
  40c586:	4d 89 6e 08          	mov    %r13,0x8(%r14)
                            : FCS_NO_SHUFFLING);
  40c58a:	75 74                	jne    40c600 <resume_solution+0x2310>
                *tests_list_struct_ptr = (typeof(*tests_list_struct_ptr)){
  40c58c:	b9 1d 00 00 00       	mov    $0x1d,%ecx
  40c591:	48 89 df             	mov    %rbx,%rdi
  40c594:	31 c0                	xor    %eax,%eax
  40c596:	f3 48 ab             	rep stos %rax,%es:(%rdi)
  40c599:	4c 89 03             	mov    %r8,(%rbx)
  40c59c:	48 89 73 08          	mov    %rsi,0x8(%rbx)
                if (shuffling_type == FCS_WEIGHTING)
  40c5a0:	49 81 c4 e8 00 00 00 	add    $0xe8,%r12
  40c5a7:	48 81 c3 e8 00 00 00 	add    $0xe8,%rbx
            for (size_t group_idx = 0; group_idx < tests_order_num; ++group_idx)
  40c5ae:	4c 39 ac 24 e0 00 00 	cmp    %r13,0xe0(%rsp)
  40c5b5:	00 
  40c5b6:	0f 85 54 ff ff ff    	jne    40c510 <resume_solution+0x2220>
  40c5bc:	4d 89 f9             	mov    %r15,%r9
  40c5bf:	49 89 d5             	mov    %rdx,%r13
                SREALLOC(moves_list_of_lists->groups, moves_list_of_lists->num);
  40c5c2:	48 8b b4 24 d0 00 00 	mov    0xd0(%rsp),%rsi
  40c5c9:	00 
  40c5ca:	4c 89 cf             	mov    %r9,%rdi
        for (size_t depth_idx = 0; depth_idx < depth_num; ++depth_idx, ++unit)
  40c5cd:	49 83 c6 18          	add    $0x18,%r14
  40c5d1:	49 83 c5 18          	add    $0x18,%r13
                SREALLOC(moves_list_of_lists->groups, moves_list_of_lists->num);
  40c5d5:	e8 96 4b ff ff       	callq  401170 <realloc@plt>
            moves_list_of_lists->groups =
  40c5da:	49 89 46 f8          	mov    %rax,-0x8(%r14)
        for (size_t depth_idx = 0; depth_idx < depth_num; ++depth_idx, ++unit)
  40c5de:	4c 3b b4 24 a0 00 00 	cmp    0xa0(%rsp),%r14
  40c5e5:	00 
  40c5e6:	0f 85 c4 fe ff ff    	jne    40c4b0 <resume_solution+0x21c0>
  40c5ec:	4c 8b bc 24 b0 00 00 	mov    0xb0(%rsp),%r15
  40c5f3:	00 
  40c5f4:	e9 77 f5 ff ff       	jmpq   40bb70 <resume_solution+0x1880>
  40c5f9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
                            : FCS_NO_SHUFFLING);
  40c600:	45 8b 54 24 10       	mov    0x10(%r12),%r10d
                *tests_list_struct_ptr = (typeof(*tests_list_struct_ptr)){
  40c605:	b9 1d 00 00 00       	mov    $0x1d,%ecx
  40c60a:	48 89 df             	mov    %rbx,%rdi
  40c60d:	31 c0                	xor    %eax,%eax
  40c60f:	f3 48 ab             	rep stos %rax,%es:(%rdi)
  40c612:	4c 89 03             	mov    %r8,(%rbx)
  40c615:	48 89 73 08          	mov    %rsi,0x8(%rbx)
  40c619:	44 89 53 10          	mov    %r10d,0x10(%rbx)
                if (shuffling_type == FCS_WEIGHTING)
  40c61d:	41 83 fa 02          	cmp    $0x2,%r10d
  40c621:	0f 85 79 ff ff ff    	jne    40c5a0 <resume_solution+0x22b0>
                    tests_list_struct_ptr->weighting =
  40c627:	c4 c1 7a 6f 7c 24 18 	vmovdqu 0x18(%r12),%xmm7
        sum += befs_weights[i];
  40c62e:	c5 e9 57 d2          	vxorpd %xmm2,%xmm2,%xmm2
  40c632:	c5 f8 11 7b 18       	vmovups %xmm7,0x18(%rbx)
  40c637:	c4 c1 7a 6f 7c 24 28 	vmovdqu 0x28(%r12),%xmm7
  40c63e:	c5 f8 11 7b 28       	vmovups %xmm7,0x28(%rbx)
  40c643:	c4 c1 7a 6f 7c 24 38 	vmovdqu 0x38(%r12),%xmm7
  40c64a:	c5 f8 11 7b 38       	vmovups %xmm7,0x38(%rbx)
  40c64f:	c4 c1 7a 6f 7c 24 48 	vmovdqu 0x48(%r12),%xmm7
  40c656:	c5 f8 11 7b 48       	vmovups %xmm7,0x48(%rbx)
  40c65b:	c4 c1 7a 6f 7c 24 58 	vmovdqu 0x58(%r12),%xmm7
  40c662:	c5 f8 11 7b 58       	vmovups %xmm7,0x58(%rbx)
  40c667:	c4 c1 7a 6f 7c 24 68 	vmovdqu 0x68(%r12),%xmm7
  40c66e:	c5 f8 11 7b 68       	vmovups %xmm7,0x68(%rbx)
  40c673:	c4 c1 7a 6f 7c 24 78 	vmovdqu 0x78(%r12),%xmm7
  40c67a:	c5 f8 11 7b 78       	vmovups %xmm7,0x78(%rbx)
  40c67f:	c4 c1 7a 6f b4 24 88 	vmovdqu 0x88(%r12),%xmm6
  40c686:	00 00 00 
  40c689:	c5 f8 11 b3 88 00 00 	vmovups %xmm6,0x88(%rbx)
  40c690:	00 
  40c691:	c4 c1 7a 6f bc 24 98 	vmovdqu 0x98(%r12),%xmm7
  40c698:	00 00 00 
  40c69b:	c5 f8 11 bb 98 00 00 	vmovups %xmm7,0x98(%rbx)
  40c6a2:	00 
  40c6a3:	c4 c1 7a 6f b4 24 a8 	vmovdqu 0xa8(%r12),%xmm6
  40c6aa:	00 00 00 
  40c6ad:	c5 f8 11 b3 a8 00 00 	vmovups %xmm6,0xa8(%rbx)
  40c6b4:	00 
  40c6b5:	c4 c1 7a 6f bc 24 b8 	vmovdqu 0xb8(%r12),%xmm7
  40c6bc:	00 00 00 
  40c6bf:	c5 f8 11 bb b8 00 00 	vmovups %xmm7,0xb8(%rbx)
  40c6c6:	00 
  40c6c7:	c5 fb 10 8b b8 00 00 	vmovsd 0xb8(%rbx),%xmm1
  40c6ce:	00 
  40c6cf:	c5 fb 10 a3 c0 00 00 	vmovsd 0xc0(%rbx),%xmm4
  40c6d6:	00 
  40c6d7:	c4 c1 7a 6f ac 24 c8 	vmovdqu 0xc8(%r12),%xmm5
  40c6de:	00 00 00 
  40c6e1:	c5 73 58 ca          	vaddsd %xmm2,%xmm1,%xmm9
  40c6e5:	c5 f8 11 ab c8 00 00 	vmovups %xmm5,0xc8(%rbx)
  40c6ec:	00 
  40c6ed:	c5 fb 10 ab c8 00 00 	vmovsd 0xc8(%rbx),%xmm5
  40c6f4:	00 
  40c6f5:	c5 33 58 cc          	vaddsd %xmm4,%xmm9,%xmm9
  40c6f9:	c5 fb 10 9b d0 00 00 	vmovsd 0xd0(%rbx),%xmm3
  40c700:	00 
  40c701:	c4 c1 7a 6f b4 24 d8 	vmovdqu 0xd8(%r12),%xmm6
  40c708:	00 00 00 
  40c70b:	c5 33 58 cd          	vaddsd %xmm5,%xmm9,%xmm9
  40c70f:	c5 f8 11 b3 d8 00 00 	vmovups %xmm6,0xd8(%rbx)
  40c716:	00 
  40c717:	c5 7b 10 83 d8 00 00 	vmovsd 0xd8(%rbx),%xmm8
  40c71e:	00 
  40c71f:	c5 fb 10 bb e0 00 00 	vmovsd 0xe0(%rbx),%xmm7
  40c726:	00 
    if (sum < 1e-6)
  40c727:	c5 fb 10 35 b9 4d 00 	vmovsd 0x4db9(%rip),%xmm6        # 4114e8 <fc_solve_is_parent_buf+0xf28>
  40c72e:	00 
        sum += befs_weights[i];
  40c72f:	c5 33 58 cb          	vaddsd %xmm3,%xmm9,%xmm9
    if (sum < 1e-6)
  40c733:	c5 fb 10 05 b5 4d 00 	vmovsd 0x4db5(%rip),%xmm0        # 4114f0 <fc_solve_is_parent_buf+0xf30>
  40c73a:	00 
        sum += befs_weights[i];
  40c73b:	c4 41 33 58 c8       	vaddsd %xmm8,%xmm9,%xmm9
  40c740:	c5 33 58 cf          	vaddsd %xmm7,%xmm9,%xmm9
    if (sum < 1e-6)
  40c744:	c4 c1 79 2f c1       	vcomisd %xmm9,%xmm0
  40c749:	77 05                	ja     40c750 <resume_solution+0x2460>
  40c74b:	c4 c1 4b 5e f1       	vdivsd %xmm9,%xmm6,%xmm6
        W(FCS_BEFS_WEIGHT_CARDS_OUT) / (LOCAL_DECKS_NUM * 52);
  40c750:	c5 f3 59 ce          	vmulsd %xmm6,%xmm1,%xmm1
    const double num_cards_out_factor =
  40c754:	c5 7b 10 0d 9c 4d 00 	vmovsd 0x4d9c(%rip),%xmm9        # 4114f8 <fc_solve_is_parent_buf+0xf38>
  40c75b:	00 
        (weighting->max_sequence_move_factor ||
  40c75c:	be 01 00 00 00       	mov    $0x1,%esi
    fcs_hard_thread *const hard_thread = soft_thread->hard_thread;
  40c761:	48 8b 84 24 b0 00 00 	mov    0xb0(%rsp),%rax
  40c768:	00 
        W(FCS_BEFS_WEIGHT_MAX_SEQUENCE_MOVE) /
  40c769:	c5 db 59 e6          	vmulsd %xmm6,%xmm4,%xmm4
        W(FCS_BEFS_WEIGHT_CARDS_UNDER_SEQUENCES) /
  40c76d:	c5 d3 59 ee          	vmulsd %xmm6,%xmm5,%xmm5
        W(FCS_BEFS_WEIGHT_MAX_SEQUENCE_MOVE) /
  40c771:	c5 db 5e 25 87 4d 00 	vdivsd 0x4d87(%rip),%xmm4,%xmm4        # 411500 <fc_solve_is_parent_buf+0xf40>
  40c778:	00 
        W(FCS_BEFS_WEIGHT_SEQS_OVER_RENEGADE_CARDS) /
  40c779:	c5 e3 59 de          	vmulsd %xmm6,%xmm3,%xmm3
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40c77d:	c5 3b 59 c6          	vmulsd %xmm6,%xmm8,%xmm8
        W(FCS_BEFS_WEIGHT_SEQS_OVER_RENEGADE_CARDS) /
  40c781:	c5 e3 5e 1d 7f 4d 00 	vdivsd 0x4d7f(%rip),%xmm3,%xmm3        # 411508 <fc_solve_is_parent_buf+0xf48>
  40c788:	00 
    fcs_hard_thread *const hard_thread = soft_thread->hard_thread;
  40c789:	48 8b 00             	mov    (%rax),%rax
        W(FCS_BEFS_WEIGHT_NUM_CARDS_NOT_ON_PARENTS) / (LOCAL_DECKS_NUM * 52);
  40c78c:	c5 c3 59 f6          	vmulsd %xmm6,%xmm7,%xmm6
    weighting->max_sequence_move_factor =
  40c790:	c5 fb 11 63 20       	vmovsd %xmm4,0x20(%rbx)
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40c795:	c5 3b 5e 05 73 4d 00 	vdivsd 0x4d73(%rip),%xmm8,%xmm8        # 411510 <fc_solve_is_parent_buf+0xf50>
  40c79c:	00 
        num_cards_out_lookup_table[i] = out_sum;
  40c79d:	48 c7 43 48 00 00 00 	movq   $0x0,0x48(%rbx)
  40c7a4:	00 
    const double num_cards_out_factor =
  40c7a5:	c4 c1 73 5e c9       	vdivsd %xmm9,%xmm1,%xmm1
        W(FCS_BEFS_WEIGHT_NUM_CARDS_NOT_ON_PARENTS) / (LOCAL_DECKS_NUM * 52);
  40c7aa:	c4 41 4b 5e c9       	vdivsd %xmm9,%xmm6,%xmm9
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c7af:	c5 f3 58 c2          	vaddsd %xmm2,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c7b3:	c5 fb 11 43 50       	vmovsd %xmm0,0x50(%rbx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c7b8:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c7bc:	c5 fb 11 43 58       	vmovsd %xmm0,0x58(%rbx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c7c1:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c7c5:	c5 fb 11 43 60       	vmovsd %xmm0,0x60(%rbx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c7ca:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c7ce:	c5 fb 11 43 68       	vmovsd %xmm0,0x68(%rbx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c7d3:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c7d7:	c5 fb 11 43 70       	vmovsd %xmm0,0x70(%rbx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c7dc:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c7e0:	c5 fb 11 43 78       	vmovsd %xmm0,0x78(%rbx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c7e5:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c7e9:	c5 fb 11 83 80 00 00 	vmovsd %xmm0,0x80(%rbx)
  40c7f0:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c7f1:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c7f5:	c5 fb 11 83 88 00 00 	vmovsd %xmm0,0x88(%rbx)
  40c7fc:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c7fd:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c801:	c5 fb 11 83 90 00 00 	vmovsd %xmm0,0x90(%rbx)
  40c808:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c809:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c80d:	c5 fb 11 83 98 00 00 	vmovsd %xmm0,0x98(%rbx)
  40c814:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c815:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c819:	c5 fb 11 83 a0 00 00 	vmovsd %xmm0,0xa0(%rbx)
  40c820:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c821:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c825:	c5 fb 11 83 a8 00 00 	vmovsd %xmm0,0xa8(%rbx)
  40c82c:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c82d:	c5 f3 58 c0          	vaddsd %xmm0,%xmm1,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c831:	c5 fb 11 83 b0 00 00 	vmovsd %xmm0,0xb0(%rbx)
  40c838:	00 
        W(FCS_BEFS_WEIGHT_CARDS_UNDER_SEQUENCES) /
  40c839:	c5 d3 5e 68 08       	vdivsd 0x8(%rax),%xmm5,%xmm5
        (weighting->max_sequence_move_factor ||
  40c83e:	c5 f9 2e ea          	vucomisd %xmm2,%xmm5
    weighting->cards_under_sequences_factor =
  40c842:	c5 fb 11 6b 28       	vmovsd %xmm5,0x28(%rbx)
    weighting->seqs_over_renegade_cards_factor =
  40c847:	c5 fb 11 5b 30       	vmovsd %xmm3,0x30(%rbx)
        (weighting->max_sequence_move_factor ||
  40c84c:	0f 9a c0             	setp   %al
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40c84f:	c5 7b 11 43 38       	vmovsd %xmm8,0x38(%rbx)
        (weighting->max_sequence_move_factor ||
  40c854:	0f 45 c6             	cmovne %esi,%eax
            weighting->cards_under_sequences_factor ||
  40c857:	c5 f9 2e e2          	vucomisd %xmm2,%xmm4
    weighting->num_cards_not_on_parents_factor =
  40c85b:	c5 7b 11 4b 40       	vmovsd %xmm9,0x40(%rbx)
            weighting->cards_under_sequences_factor ||
  40c860:	0f 9a c1             	setp   %cl
  40c863:	0f 45 ce             	cmovne %esi,%ecx
    weighting->should_go_over_stacks =
  40c866:	09 c8                	or     %ecx,%eax
            weighting->cards_under_sequences_factor ||
  40c868:	c5 f9 2e da          	vucomisd %xmm2,%xmm3
  40c86c:	0f 9a c1             	setp   %cl
  40c86f:	0f 45 ce             	cmovne %esi,%ecx
    weighting->should_go_over_stacks =
  40c872:	09 c8                	or     %ecx,%eax
  40c874:	88 43 18             	mov    %al,0x18(%rbx)
  40c877:	e9 24 fd ff ff       	jmpq   40c5a0 <resume_solution+0x22b0>
  40c87c:	0f 1f 40 00          	nopl   0x0(%rax)
    for (; (DEPTH() >= GET_DEPTH(curr_by_depth_unit)); ++curr_by_depth_unit)
  40c880:	48 89 94 24 d0 00 00 	mov    %rdx,0xd0(%rsp)
  40c887:	00 
    RECALC_BY_DEPTH_LIMITS();
  40c888:	48 c7 84 24 c8 00 00 	movq   $0x0,0xc8(%rsp)
  40c88f:	00 00 00 00 00 
  40c894:	e9 15 dd ff ff       	jmpq   40a5ae <resume_solution+0x2be>
  40c899:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    char *const new_data = meta_request_new_buffer(allocator->meta);
  40c8a0:	48 8b 93 f8 00 00 00 	mov    0xf8(%rbx),%rdx
    char *const ret = meta_alloc->recycle_bin;
  40c8a7:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40c8aa:	48 85 c0             	test   %rax,%rax
  40c8ad:	0f 84 cd 00 00 00    	je     40c980 <resume_solution+0x2690>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40c8b3:	48 8b 08             	mov    (%rax),%rcx
  40c8b6:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40c8b9:	48 8b 93 d8 00 00 00 	mov    0xd8(%rbx),%rdx
  40c8c0:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40c8c3:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  40c8c7:	48 89 83 d8 00 00 00 	mov    %rax,0xd8(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40c8ce:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40c8d4:	48 89 93 f0 00 00 00 	mov    %rdx,0xf0(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40c8db:	48 89 83 e0 00 00 00 	mov    %rax,0xe0(%rbx)
  40c8e2:	e9 05 f5 ff ff       	jmpq   40bdec <resume_solution+0x1afc>
  40c8e7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40c8ee:	00 00 
    char *const new_data = meta_request_new_buffer(allocator->meta);
  40c8f0:	48 8b 93 f8 00 00 00 	mov    0xf8(%rbx),%rdx
    char *const ret = meta_alloc->recycle_bin;
  40c8f7:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40c8fa:	48 85 c0             	test   %rax,%rax
  40c8fd:	74 71                	je     40c970 <resume_solution+0x2680>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40c8ff:	48 8b 08             	mov    (%rax),%rcx
  40c902:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40c905:	48 8b 93 d8 00 00 00 	mov    0xd8(%rbx),%rdx
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40c90c:	4c 8d 60 08          	lea    0x8(%rax),%r12
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40c910:	48 89 10             	mov    %rdx,(%rax)
    allocator->old_list = new_data;
  40c913:	48 89 83 d8 00 00 00 	mov    %rax,0xd8(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40c91a:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40c920:	4c 89 a3 f0 00 00 00 	mov    %r12,0xf0(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40c927:	48 89 83 e0 00 00 00 	mov    %rax,0xe0(%rbx)
  40c92e:	e9 92 f4 ff ff       	jmpq   40bdc5 <resume_solution+0x1ad5>
  40c933:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c93a:	00 00 00 00 
  40c93e:	66 90                	xchg   %ax,%ax
            for (size_t group_idx = 0; group_idx < tests_order_num; ++group_idx)
  40c940:	48 c7 84 24 d0 00 00 	movq   $0x0,0xd0(%rsp)
  40c947:	00 00 00 00 00 
  40c94c:	e9 71 fc ff ff       	jmpq   40c5c2 <resume_solution+0x22d2>
  40c951:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c958:	00 00 00 00 
  40c95c:	0f 1f 40 00          	nopl   0x0(%rax)
        for (size_t group_idx = 0;
  40c960:	31 d2                	xor    %edx,%edx
  40c962:	e9 57 f5 ff ff       	jmpq   40bebe <resume_solution+0x1bce>
  40c967:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40c96e:	00 00 
        return malloc(ALLOCED_SIZE);
  40c970:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40c975:	e8 76 47 ff ff       	callq  4010f0 <malloc@plt>
  40c97a:	eb 89                	jmp    40c905 <resume_solution+0x2615>
  40c97c:	0f 1f 40 00          	nopl   0x0(%rax)
  40c980:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40c985:	e8 66 47 ff ff       	callq  4010f0 <malloc@plt>
  40c98a:	e9 2a ff ff ff       	jmpq   40c8b9 <resume_solution+0x25c9>
  40c98f:	90                   	nop
            if (!fc_solve_initial_user_state_to_c(user->state_string_copy,
  40c990:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40c997:	00 
    memset(&(state->s), 0, sizeof(state->s));
  40c998:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  40c99c:	4c 8d 80 d8 05 00 00 	lea    0x5d8(%rax),%r8
  40c9a3:	c5 f8 11 80 d8 05 00 	vmovups %xmm0,0x5d8(%rax)
  40c9aa:	00 
  40c9ab:	48 8d 90 48 0a 00 00 	lea    0xa48(%rax),%rdx
  40c9b2:	c4 c1 78 11 40 10    	vmovups %xmm0,0x10(%r8)
  40c9b8:	48 05 48 06 00 00    	add    $0x648,%rax
  40c9be:	4c 89 c1             	mov    %r8,%rcx
  40c9c1:	c4 c1 78 11 40 20    	vmovups %xmm0,0x20(%r8)
  40c9c7:	c4 c1 78 11 40 30    	vmovups %xmm0,0x30(%r8)
  40c9cd:	49 c7 40 40 00 00 00 	movq   $0x0,0x40(%r8)
  40c9d4:	00 
    for (i = 0; i < STACKS_NUM__VAL; ++i)
  40c9d5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c9dc:	00 00 00 00 
        memset(state->s.columns[i] = &indirect_stacks_buffer[i << 7], '\0',
  40c9e0:	48 89 01             	mov    %rax,(%rcx)
  40c9e3:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  40c9e7:	48 83 e8 80          	sub    $0xffffffffffffff80,%rax
  40c9eb:	48 83 c1 08          	add    $0x8,%rcx
  40c9ef:	c5 f8 11 40 80       	vmovups %xmm0,-0x80(%rax)
  40c9f4:	c5 f8 11 40 90       	vmovups %xmm0,-0x70(%rax)
  40c9f9:	c5 f8 11 40 a0       	vmovups %xmm0,-0x60(%rax)
  40c9fe:	c7 40 b0 00 00 00 00 	movl   $0x0,-0x50(%rax)
  40ca05:	c6 40 b4 00          	movb   $0x0,-0x4c(%rax)
    for (i = 0; i < STACKS_NUM__VAL; ++i)
  40ca09:	48 39 c2             	cmp    %rax,%rdx
  40ca0c:	75 d2                	jne    40c9e0 <resume_solution+0x26f0>
    state->info.parent = NULL;
  40ca0e:	4c 8b a4 24 e8 00 00 	mov    0xe8(%rsp),%r12
  40ca15:	00 
    state->info.num_active_children = 0;
  40ca16:	31 f6                	xor    %esi,%esi
    state->info.stacks_copy_on_write_flags = 0;
  40ca18:	45 31 d2             	xor    %r10d,%r10d
  40ca1b:	41 bb 0d f0 40 00    	mov    $0x40f00d,%r11d
                while ((*str != ' ') && (*str != '\t') && (*str != '\n') &&
  40ca21:	49 b9 00 26 00 00 01 	movabs $0x100002600,%r9
  40ca28:	00 00 00 
static inline const char *try_str_prefix(
    const char *const str, const char *const prefix)
{
    register const size_t len = strlen(prefix);

    return (strncmp(str, prefix, len) ? NULL : str + len);
  40ca2b:	48 c7 c3 f6 ff ff ff 	mov    $0xfffffffffffffff6,%rbx
    state->info.parent = NULL;
  40ca32:	49 c7 84 24 20 06 00 	movq   $0x0,0x620(%r12)
  40ca39:	00 00 00 00 00 
    state->info.depth = 0;
  40ca3e:	41 c7 84 24 28 06 00 	movl   $0x0,0x628(%r12)
  40ca45:	00 00 00 00 00 
    state->info.visited = 0;
  40ca4a:	41 c6 84 24 2e 06 00 	movb   $0x0,0x62e(%r12)
  40ca51:	00 00 
    state->info.num_active_children = 0;
  40ca53:	66 41 89 b4 24 2c 06 	mov    %si,0x62c(%r12)
  40ca5a:	00 00 
    memset(state->info.scan_visited, '\0', sizeof(state->info.scan_visited));
  40ca5c:	41 c7 84 24 2f 06 00 	movl   $0x0,0x62f(%r12)
  40ca63:	00 00 00 00 00 
    state->info.stacks_copy_on_write_flags = 0;
  40ca68:	41 c7 84 24 34 06 00 	movl   $0x0,0x634(%r12)
  40ca6f:	00 00 00 00 00 
  40ca74:	b9 0a 00 00 00       	mov    $0xa,%ecx
  40ca79:	48 89 d6             	mov    %rdx,%rsi
  40ca7c:	4c 89 df             	mov    %r11,%rdi
  40ca7f:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  40ca81:	0f 97 c0             	seta   %al
  40ca84:	1c 00                	sbb    $0x0,%al
  40ca86:	84 c0                	test   %al,%al
  40ca88:	0f 85 02 07 00 00    	jne    40d190 <resume_solution+0x2ea0>
        if (new_str)
  40ca8e:	48 89 d0             	mov    %rdx,%rax
  40ca91:	48 83 c0 0a          	add    $0xa,%rax
  40ca95:	0f 84 d5 08 00 00    	je     40d370 <resume_solution+0x3080>
                fcs_empty_freecell(out, c);
  40ca9b:	41 c7 84 24 18 06 00 	movl   $0x0,0x618(%r12)
  40caa2:	00 00 00 00 00 
            for (size_t c = 0; c < FREECELLS_NUM__VAL; ++c)
  40caa7:	31 c9                	xor    %ecx,%ecx
                while ((*str == ' ') || (*str == '\t'))
  40caa9:	0f b6 10             	movzbl (%rax),%edx
  40caac:	80 fa 20             	cmp    $0x20,%dl
  40caaf:	75 1b                	jne    40cacc <resume_solution+0x27dc>
  40cab1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40cab8:	00 00 00 00 
  40cabc:	0f 1f 40 00          	nopl   0x0(%rax)
                    ++str;
  40cac0:	48 83 c0 01          	add    $0x1,%rax
                while ((*str == ' ') || (*str == '\t'))
  40cac4:	0f b6 10             	movzbl (%rax),%edx
  40cac7:	80 fa 20             	cmp    $0x20,%dl
  40caca:	74 f4                	je     40cac0 <resume_solution+0x27d0>
  40cacc:	80 fa 09             	cmp    $0x9,%dl
  40cacf:	74 ef                	je     40cac0 <resume_solution+0x27d0>
                if ((*str == '\r') || (*str == '\n'))
  40cad1:	80 fa 0d             	cmp    $0xd,%dl
  40cad4:	0f 84 91 00 00 00    	je     40cb6b <resume_solution+0x287b>
  40cada:	80 fa 0a             	cmp    $0xa,%dl
  40cadd:	0f 84 88 00 00 00    	je     40cb6b <resume_solution+0x287b>
                fcs_put_card_in_freecell(out, c,
  40cae3:	80 fa 2a             	cmp    $0x2a,%dl
  40cae6:	74 09                	je     40caf1 <resume_solution+0x2801>
  40cae8:	80 fa 2d             	cmp    $0x2d,%dl
  40caeb:	0f 85 af 00 00 00    	jne    40cba0 <resume_solution+0x28b0>
  40caf1:	31 d2                	xor    %edx,%edx
  40caf3:	41 88 94 0c 18 06 00 	mov    %dl,0x618(%r12,%rcx,1)
  40cafa:	00 
            for (size_t c = 0; c < FREECELLS_NUM__VAL; ++c)
  40cafb:	48 83 c1 01          	add    $0x1,%rcx
  40caff:	48 83 f9 04          	cmp    $0x4,%rcx
  40cb03:	75 0f                	jne    40cb14 <resume_solution+0x2824>
  40cb05:	eb 61                	jmp    40cb68 <resume_solution+0x2878>
  40cb07:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40cb0e:	00 00 
                        ++str;
  40cb10:	48 83 c0 01          	add    $0x1,%rax
                    while (((*str) != ' ') && ((*str) != '\t') &&
  40cb14:	0f b6 10             	movzbl (%rax),%edx
  40cb17:	80 fa 20             	cmp    $0x20,%dl
  40cb1a:	0f 84 e0 07 00 00    	je     40d300 <resume_solution+0x3010>
  40cb20:	80 fa 09             	cmp    $0x9,%dl
  40cb23:	0f 84 d7 07 00 00    	je     40d300 <resume_solution+0x3010>
                           ((*str) != '\n') && ((*str) != '\r'))
  40cb29:	80 fa 0a             	cmp    $0xa,%dl
  40cb2c:	74 3d                	je     40cb6b <resume_solution+0x287b>
  40cb2e:	80 fa 0d             	cmp    $0xd,%dl
  40cb31:	74 38                	je     40cb6b <resume_solution+0x287b>
                        HANDLE_EOS();
  40cb33:	84 d2                	test   %dl,%dl
  40cb35:	75 d9                	jne    40cb10 <resume_solution+0x2820>
  40cb37:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40cb3e:	00 00 
                return (user->ret_code = FCS_STATE_INVALID_STATE);
  40cb40:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40cb47:	00 
  40cb48:	41 bd 08 00 00 00    	mov    $0x8,%r13d
  40cb4e:	c7 80 38 06 00 00 08 	movl   $0x8,0x638(%rax)
  40cb55:	00 00 00 
  40cb58:	c5 f8 77             	vzeroupper 
  40cb5b:	e9 95 d8 ff ff       	jmpq   40a3f5 <resume_solution+0x105>
                HANDLE_EOS();
  40cb60:	84 d2                	test   %dl,%dl
  40cb62:	74 dc                	je     40cb40 <resume_solution+0x2850>
                ++str;
  40cb64:	48 83 c0 01          	add    $0x1,%rax
            while (*str != '\n')
  40cb68:	0f b6 10             	movzbl (%rax),%edx
  40cb6b:	80 fa 0a             	cmp    $0xa,%dl
  40cb6e:	75 f0                	jne    40cb60 <resume_solution+0x2870>
    for (size_t s = 0; s < STACKS_NUM__VAL; s++)
  40cb70:	49 83 fa 07          	cmp    $0x7,%r10
  40cb74:	76 12                	jbe    40cb88 <resume_solution+0x2898>
  40cb76:	eb 3e                	jmp    40cbb6 <resume_solution+0x28c6>
  40cb78:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40cb7f:	00 
                HANDLE_EOS();
  40cb80:	84 d2                	test   %dl,%dl
  40cb82:	74 bc                	je     40cb40 <resume_solution+0x2850>
                ++str;
  40cb84:	48 83 c0 01          	add    $0x1,%rax
            while ((*str) != '\n')
  40cb88:	0f b6 10             	movzbl (%rax),%edx
  40cb8b:	80 fa 0a             	cmp    $0xa,%dl
  40cb8e:	75 f0                	jne    40cb80 <resume_solution+0x2890>
            ++str;
  40cb90:	48 8d 50 01          	lea    0x1(%rax),%rdx
  40cb94:	e9 db fe ff ff       	jmpq   40ca74 <resume_solution+0x2784>
  40cb99:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
                fcs_put_card_in_freecell(out, c,
  40cba0:	48 89 c2             	mov    %rax,%rdx
        switch (FC_SOLVE_MAP_CHAR(*string))
  40cba3:	80 3a 54             	cmpb   $0x54,(%rdx)
  40cba6:	0f 87 a2 0c 00 00    	ja     40d84e <resume_solution+0x355e>
  40cbac:	0f b6 32             	movzbl (%rdx),%esi
  40cbaf:	ff 24 f5 e0 f1 40 00 	jmpq   *0x40f1e0(,%rsi,8)
            fc_solve_canonize_state(&(user->state.s)PASS_FREECELLS(
  40cbb6:	4c 89 c7             	mov    %r8,%rdi
  40cbb9:	c5 f8 77             	vzeroupper 
  40cbbc:	e8 7f 49 ff ff       	callq  401540 <fc_solve_canonize_state>
        ST_LOOP_START() { soft_thread->hard_thread = instance; }
  40cbc1:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40cbc8:	00 
  40cbc9:	48 8b 8c 24 e8 00 00 	mov    0xe8(%rsp),%rcx
  40cbd0:	00 
  40cbd1:	48 8b 90 20 05 00 00 	mov    0x520(%rax),%rdx
  40cbd8:	48 8b b0 c0 00 00 00 	mov    0xc0(%rax),%rsi
  40cbdf:	48 69 fa f8 01 00 00 	imul   $0x1f8,%rdx,%rdi
  40cbe6:	48 89 f0             	mov    %rsi,%rax
  40cbe9:	48 01 f7             	add    %rsi,%rdi
  40cbec:	48 39 fe             	cmp    %rdi,%rsi
  40cbef:	73 1d                	jae    40cc0e <resume_solution+0x291e>
  40cbf1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40cbf8:	00 00 00 00 
  40cbfc:	0f 1f 40 00          	nopl   0x0(%rax)
  40cc00:	48 89 08             	mov    %rcx,(%rax)
  40cc03:	48 05 f8 01 00 00    	add    $0x1f8,%rax
  40cc09:	48 39 c7             	cmp    %rax,%rdi
  40cc0c:	77 f2                	ja     40cc00 <resume_solution+0x2910>
    (*st_idx_ptr) = scan_idx;
  40cc0e:	48 8b 8c 24 e8 00 00 	mov    0xe8(%rsp),%rcx
  40cc15:	00 
        set_next_soft_thread(hard_thread, 0,
  40cc16:	48 8b 86 e8 01 00 00 	mov    0x1e8(%rsi),%rax
    (*st_idx_ptr) = scan_idx;
  40cc1d:	48 c7 81 d0 00 00 00 	movq   $0x0,0xd0(%rcx)
  40cc24:	00 00 00 00 
        NUM_CHECKED_STATES + quota;
  40cc28:	4c 8b 01             	mov    (%rcx),%r8
  40cc2b:	4c 01 c0             	add    %r8,%rax
  40cc2e:	48 89 81 c8 00 00 00 	mov    %rax,0xc8(%rcx)
        if (st_idx < num_soft_threads)
  40cc35:	48 85 d2             	test   %rdx,%rdx
  40cc38:	0f 8e ec 00 00 00    	jle    40cd2a <resume_solution+0x2a3a>
  40cc3e:	48 89 f3             	mov    %rsi,%rbx
    size_t total_move_funcs_bitmask = 0;
  40cc41:	45 31 c9             	xor    %r9d,%r9d
            *moves_order |= (1 << (test_ptr->idx));
  40cc44:	41 bc 01 00 00 00    	mov    $0x1,%r12d
  40cc4a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            &(soft_thread->by_depth_moves_order.by_depth_moves[0].moves_order));
  40cc50:	48 8b 43 18          	mov    0x18(%rbx),%rax
    const fcs_moves_group *const groups_end = group_ptr + st_tests_order->num;
  40cc54:	4c 69 50 08 e8 00 00 	imul   $0xe8,0x8(%rax),%r10
  40cc5b:	00 
        accumulate_tests_by_ptr((size_t *)context,
  40cc5c:	48 8b 50 10          	mov    0x10(%rax),%rdx
    const fcs_moves_group *const groups_end = group_ptr + st_tests_order->num;
  40cc60:	49 01 d2             	add    %rdx,%r10
    for (; group_ptr < groups_end; ++group_ptr)
  40cc63:	4c 39 d2             	cmp    %r10,%rdx
  40cc66:	73 3c                	jae    40cca4 <resume_solution+0x29b4>
  40cc68:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40cc6f:	00 
        const fcs_move_func *test_ptr = group_ptr->move_funcs;
  40cc70:	48 8b 02             	mov    (%rdx),%rax
        const fcs_move_func *const tests_end = test_ptr + group_ptr->num;
  40cc73:	48 8b 4a 08          	mov    0x8(%rdx),%rcx
  40cc77:	4c 8d 1c c8          	lea    (%rax,%rcx,8),%r11
        for (; test_ptr < tests_end; ++test_ptr)
  40cc7b:	4c 39 d8             	cmp    %r11,%rax
  40cc7e:	73 18                	jae    40cc98 <resume_solution+0x29a8>
            *moves_order |= (1 << (test_ptr->idx));
  40cc80:	48 8b 08             	mov    (%rax),%rcx
  40cc83:	45 89 e6             	mov    %r12d,%r14d
        for (; test_ptr < tests_end; ++test_ptr)
  40cc86:	48 83 c0 08          	add    $0x8,%rax
            *moves_order |= (1 << (test_ptr->idx));
  40cc8a:	41 d3 e6             	shl    %cl,%r14d
  40cc8d:	49 63 ce             	movslq %r14d,%rcx
  40cc90:	49 09 c9             	or     %rcx,%r9
        for (; test_ptr < tests_end; ++test_ptr)
  40cc93:	49 39 c3             	cmp    %rax,%r11
  40cc96:	77 e8                	ja     40cc80 <resume_solution+0x2990>
    for (; group_ptr < groups_end; ++group_ptr)
  40cc98:	48 81 c2 e8 00 00 00 	add    $0xe8,%rdx
  40cc9f:	49 39 d2             	cmp    %rdx,%r10
  40cca2:	77 cc                	ja     40cc70 <resume_solution+0x2980>
        if (st_idx < num_soft_threads)
  40cca4:	48 81 c3 f8 01 00 00 	add    $0x1f8,%rbx
  40ccab:	48 39 df             	cmp    %rbx,%rdi
  40ccae:	75 a0                	jne    40cc50 <resume_solution+0x2960>
            *moves_order |= (1 << (test_ptr->idx));
  40ccb0:	41 bc 01 00 00 00    	mov    $0x1,%r12d
  40ccb6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40ccbd:	00 00 00 
            &(soft_thread->by_depth_moves_order.by_depth_moves[0].moves_order));
  40ccc0:	48 8b 46 18          	mov    0x18(%rsi),%rax
        size_t moves_order = 0;
  40ccc4:	45 31 db             	xor    %r11d,%r11d
    const fcs_moves_group *const groups_end = group_ptr + st_tests_order->num;
  40ccc7:	4c 69 50 08 e8 00 00 	imul   $0xe8,0x8(%rax),%r10
  40ccce:	00 
        accumulate_tests_by_ptr(&moves_order,
  40cccf:	48 8b 50 10          	mov    0x10(%rax),%rdx
    const fcs_moves_group *const groups_end = group_ptr + st_tests_order->num;
  40ccd3:	49 01 d2             	add    %rdx,%r10
    for (; group_ptr < groups_end; ++group_ptr)
  40ccd6:	4c 39 d2             	cmp    %r10,%rdx
  40ccd9:	73 39                	jae    40cd14 <resume_solution+0x2a24>
  40ccdb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        const fcs_move_func *test_ptr = group_ptr->move_funcs;
  40cce0:	48 8b 02             	mov    (%rdx),%rax
        const fcs_move_func *const tests_end = test_ptr + group_ptr->num;
  40cce3:	48 8b 4a 08          	mov    0x8(%rdx),%rcx
  40cce7:	48 8d 1c c8          	lea    (%rax,%rcx,8),%rbx
        for (; test_ptr < tests_end; ++test_ptr)
  40cceb:	48 39 d8             	cmp    %rbx,%rax
  40ccee:	73 18                	jae    40cd08 <resume_solution+0x2a18>
            *moves_order |= (1 << (test_ptr->idx));
  40ccf0:	48 8b 08             	mov    (%rax),%rcx
  40ccf3:	45 89 e6             	mov    %r12d,%r14d
        for (; test_ptr < tests_end; ++test_ptr)
  40ccf6:	48 83 c0 08          	add    $0x8,%rax
            *moves_order |= (1 << (test_ptr->idx));
  40ccfa:	41 d3 e6             	shl    %cl,%r14d
  40ccfd:	49 63 ce             	movslq %r14d,%rcx
  40cd00:	49 09 cb             	or     %rcx,%r11
        for (; test_ptr < tests_end; ++test_ptr)
  40cd03:	48 39 c3             	cmp    %rax,%rbx
  40cd06:	77 e8                	ja     40ccf0 <resume_solution+0x2a00>
    for (; group_ptr < groups_end; ++group_ptr)
  40cd08:	48 81 c2 e8 00 00 00 	add    $0xe8,%rdx
  40cd0f:	49 39 d2             	cmp    %rdx,%r10
  40cd12:	77 cc                	ja     40cce0 <resume_solution+0x29f0>
        STRUCT_SET_FLAG_TO(soft_thread, FCS_SOFT_THREAD_IS_A_COMPLETE_SCAN,
  40cd14:	4d 39 cb             	cmp    %r9,%r11
  40cd17:	0f 94 86 e2 01 00 00 	sete   0x1e2(%rsi)
        if (st_idx < num_soft_threads)
  40cd1e:	48 81 c6 f8 01 00 00 	add    $0x1f8,%rsi
  40cd25:	48 39 f7             	cmp    %rsi,%rdi
  40cd28:	75 96                	jne    40ccc0 <resume_solution+0x29d0>
        user->init_num_checked_states.num_checked_states =
  40cd2a:	4c 8b b4 24 e8 00 00 	mov    0xe8(%rsp),%r14
  40cd31:	00 
        (hash_table_entry *)calloc(initial_hash_size, sizeof(hash->entries[0]));
  40cd32:	be 08 00 00 00       	mov    $0x8,%esi
  40cd37:	bf 00 08 00 00       	mov    $0x800,%edi
    hash->num_elems = 0;
  40cd3c:	c5 f9 6f 3d dc 47 00 	vmovdqa 0x47dc(%rip),%xmm7        # 411520 <fc_solve_is_parent_buf+0xf60>
  40cd43:	00 
    fc_solve_hash_init(instance->meta_alloc, &(instance->hash),
  40cd44:	49 8b 9e b0 05 00 00 	mov    0x5b0(%r14),%rbx
        user->init_num_checked_states.num_checked_states =
  40cd4b:	4d 89 86 d0 05 00 00 	mov    %r8,0x5d0(%r14)
  40cd52:	c4 c1 78 11 7e 28    	vmovups %xmm7,0x28(%r14)
        (hash_table_entry *)calloc(initial_hash_size, sizeof(hash->entries[0]));
  40cd58:	e8 a3 43 ff ff       	callq  401100 <calloc@plt>
    allocator->old_list = NULL;
  40cd5d:	49 c7 46 38 00 00 00 	movq   $0x0,0x38(%r14)
  40cd64:	00 
    hash->entries =
  40cd65:	49 89 46 10          	mov    %rax,0x10(%r14)
    hash->hash_type = hash_type;
  40cd69:	48 b8 01 00 00 00 00 	movabs $0x80000000001,%rax
  40cd70:	08 00 00 
  40cd73:	49 89 46 18          	mov    %rax,0x18(%r14)
    char *const ret = meta_alloc->recycle_bin;
  40cd77:	48 8b 03             	mov    (%rbx),%rax
    hash->size_bitmask = initial_hash_size - 1;
  40cd7a:	41 c7 46 20 ff 07 00 	movl   $0x7ff,0x20(%r14)
  40cd81:	00 
    allocator->meta = meta_alloc;
  40cd82:	49 89 5e 58          	mov    %rbx,0x58(%r14)
    if (ret)
  40cd86:	48 85 c0             	test   %rax,%rax
  40cd89:	0f 84 11 07 00 00    	je     40d4a0 <resume_solution+0x31b0>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40cd8f:	48 8b 10             	mov    (%rax),%rdx
  40cd92:	48 8b bc 24 e8 00 00 	mov    0xe8(%rsp),%rdi
  40cd99:	00 
  40cd9a:	48 89 13             	mov    %rdx,(%rbx)
        return ret;
  40cd9d:	48 8b 57 38          	mov    0x38(%rdi),%rdx
  40cda1:	49 89 fe             	mov    %rdi,%r14
    hash->num_elems = 0;
  40cda4:	c5 f9 6f 3d 74 47 00 	vmovdqa 0x4774(%rip),%xmm7        # 411520 <fc_solve_is_parent_buf+0xf60>
  40cdab:	00 
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40cdac:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40cdaf:	48 8d 50 08          	lea    0x8(%rax),%rdx
        (hash_table_entry *)calloc(initial_hash_size, sizeof(hash->entries[0]));
  40cdb3:	be 08 00 00 00       	mov    $0x8,%esi
    allocator->old_list = new_data;
  40cdb8:	49 89 46 38          	mov    %rax,0x38(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40cdbc:	48 05 80 fe 00 00    	add    $0xfe80,%rax
  40cdc2:	bf 00 08 00 00       	mov    $0x800,%edi
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40cdc7:	49 89 56 50          	mov    %rdx,0x50(%r14)
  40cdcb:	49 89 56 48          	mov    %rdx,0x48(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40cdcf:	49 89 46 40          	mov    %rax,0x40(%r14)
    hash->num_elems = 0;
  40cdd3:	c4 c1 78 11 7e 78    	vmovups %xmm7,0x78(%r14)
        (hash_table_entry *)calloc(initial_hash_size, sizeof(hash->entries[0]));
  40cdd9:	e8 22 43 ff ff       	callq  401100 <calloc@plt>
    hash->size_bitmask = initial_hash_size - 1;
  40cdde:	41 c7 46 70 ff 07 00 	movl   $0x7ff,0x70(%r14)
  40cde5:	00 
    hash->entries =
  40cde6:	49 89 46 60          	mov    %rax,0x60(%r14)
    hash->hash_type = hash_type;
  40cdea:	48 b8 00 00 00 00 00 	movabs $0x80000000000,%rax
  40cdf1:	08 00 00 
  40cdf4:	49 89 46 68          	mov    %rax,0x68(%r14)
  40cdf8:	49 c7 86 88 00 00 00 	movq   $0x0,0x88(%r14)
  40cdff:	00 00 00 00 
    char *const ret = meta_alloc->recycle_bin;
  40ce03:	48 8b 03             	mov    (%rbx),%rax
    allocator->meta = meta_alloc;
  40ce06:	49 89 9e a8 00 00 00 	mov    %rbx,0xa8(%r14)
    if (ret)
  40ce0d:	48 85 c0             	test   %rax,%rax
  40ce10:	0f 84 6a 06 00 00    	je     40d480 <resume_solution+0x3190>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40ce16:	48 8b 10             	mov    (%rax),%rdx
  40ce19:	48 89 13             	mov    %rdx,(%rbx)
        return ret;
  40ce1c:	49 8b 96 88 00 00 00 	mov    0x88(%r14),%rdx
    allocator->old_list = new_data;
  40ce23:	48 8b b4 24 e8 00 00 	mov    0xe8(%rsp),%rsi
  40ce2a:	00 
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40ce2b:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40ce2e:	48 8d 50 08          	lea    0x8(%rax),%rdx
    instance->state_copy = (typeof(instance->state_copy)){.s = init_state->s,
  40ce32:	b9 0c 00 00 00       	mov    $0xc,%ecx
  40ce37:	48 89 96 a0 00 00 00 	mov    %rdx,0xa0(%rsi)
  40ce3e:	c5 fa 6f 9e d8 05 00 	vmovdqu 0x5d8(%rsi),%xmm3
  40ce45:	00 
  40ce46:	48 8d be 50 05 00 00 	lea    0x550(%rsi),%rdi
  40ce4d:	48 89 96 98 00 00 00 	mov    %rdx,0x98(%rsi)
  40ce54:	48 8b 96 18 06 00 00 	mov    0x618(%rsi),%rdx
  40ce5b:	4c 8d 96 50 05 00 00 	lea    0x550(%rsi),%r10
  40ce62:	c5 fa 6f 96 e8 05 00 	vmovdqu 0x5e8(%rsi),%xmm2
  40ce69:	00 
    allocator->old_list = new_data;
  40ce6a:	48 89 86 88 00 00 00 	mov    %rax,0x88(%rsi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40ce71:	48 05 80 fe 00 00    	add    $0xfe80,%rax
  40ce77:	4d 89 d0             	mov    %r10,%r8
  40ce7a:	c5 fa 6f 8e f8 05 00 	vmovdqu 0x5f8(%rsi),%xmm1
  40ce81:	00 
  40ce82:	48 89 86 90 00 00 00 	mov    %rax,0x90(%rsi)
  40ce89:	31 c0                	xor    %eax,%eax
  40ce8b:	c5 fa 6f 86 08 06 00 	vmovdqu 0x608(%rsi),%xmm0
  40ce92:	00 
  40ce93:	4c 8d 8e 90 05 00 00 	lea    0x590(%rsi),%r9
  40ce9a:	c5 f8 29 9c 24 30 01 	vmovaps %xmm3,0x130(%rsp)
  40cea1:	00 00 
  40cea3:	f3 48 ab             	rep stos %rax,%es:(%rdi)
  40cea6:	48 89 94 24 70 01 00 	mov    %rdx,0x170(%rsp)
  40cead:	00 
  40ceae:	c5 f8 29 94 24 40 01 	vmovaps %xmm2,0x140(%rsp)
  40ceb5:	00 00 
  40ceb7:	c5 f8 29 8c 24 50 01 	vmovaps %xmm1,0x150(%rsp)
  40cebe:	00 00 
  40cec0:	c5 f8 11 9e 50 05 00 	vmovups %xmm3,0x550(%rsi)
  40cec7:	00 
  40cec8:	c5 f8 11 96 60 05 00 	vmovups %xmm2,0x560(%rsi)
  40cecf:	00 
  40ced0:	c5 f8 11 8e 70 05 00 	vmovups %xmm1,0x570(%rsi)
  40ced7:	00 
  40ced8:	48 89 96 90 05 00 00 	mov    %rdx,0x590(%rsi)
  40cedf:	c7 86 ac 05 00 00 ff 	movl   $0xffffffff,0x5ac(%rsi)
  40cee6:	ff ff ff 
  40cee9:	c5 f8 29 84 24 60 01 	vmovaps %xmm0,0x160(%rsp)
  40cef0:	00 00 
  40cef2:	c5 f8 11 86 80 05 00 	vmovups %xmm0,0x580(%rsi)
  40cef9:	00 
    fcs_seq_cards_power_type cards_under_sequences = 0;
  40cefa:	c5 f9 57 c0          	vxorpd %xmm0,%xmm0,%xmm0
  40cefe:	66 90                	xchg   %ax,%ax
        const_AUTO(col, fcs_state_get_col(*s, a));
  40cf00:	49 8b 38             	mov    (%r8),%rdi
        const_AUTO(col_len, fcs_col_len(col));
  40cf03:	0f be 07             	movsbl (%rdi),%eax
        if (col_len <= 1)
  40cf06:	3c 01                	cmp    $0x1,%al
  40cf08:	7e 47                	jle    40cf51 <resume_solution+0x2c61>
        cards_under_sequences += FCS_SEQS_OVER_RENEGADE_POWER(
  40cf0a:	83 e8 01             	sub    $0x1,%eax
    fcs_card this_card = fcs_col_get_card(col, d);
  40cf0d:	48 98                	cltq   
  40cf0f:	48 0f be 54 07 01    	movsbq 0x1(%rdi,%rax,1),%rdx
    for (; (d > 0) && ({
  40cf15:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40cf1c:	00 00 00 00 
             prev_card = fcs_col_get_card(col, d - 1);
  40cf20:	48 0f be 0c 07       	movsbq (%rdi,%rax,1),%rcx
  40cf25:	4c 63 d8             	movslq %eax,%r11
  40cf28:	48 89 ce             	mov    %rcx,%rsi
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40cf2b:	48 c1 e1 06          	shl    $0x6,%rcx
    for (; (d > 0) && ({
  40cf2f:	80 bc 0a c0 05 41 00 	cmpb   $0x0,0x4105c0(%rdx,%rcx,1)
  40cf36:	00 
  40cf37:	0f 84 b3 00 00 00    	je     40cff0 <resume_solution+0x2d00>
  40cf3d:	48 83 e8 01          	sub    $0x1,%rax
         d--, this_card = prev_card)
  40cf41:	48 0f be d6          	movsbq %sil,%rdx
    for (; (d > 0) && ({
  40cf45:	85 c0                	test   %eax,%eax
  40cf47:	75 d7                	jne    40cf20 <resume_solution+0x2c30>
  40cf49:	c5 f1 57 c9          	vxorpd %xmm1,%xmm1,%xmm1
  40cf4d:	c5 fb 58 c1          	vaddsd %xmm1,%xmm0,%xmm0
  40cf51:	49 83 c0 08          	add    $0x8,%r8
    for (int a = 0; a < INSTANCE_STACKS_NUM; a++)
  40cf55:	4d 39 c1             	cmp    %r8,%r9
  40cf58:	75 a6                	jne    40cf00 <resume_solution+0x2c10>
    instance->initial_cards_under_sequences_value = cards_under_sequences;
  40cf5a:	48 8b 9c 24 e8 00 00 	mov    0xe8(%rsp),%rbx
  40cf61:	00 
        pass_copy = FCS_STATE_keyval_pair_to_kv(&instance->state_copy);
  40cf62:	c4 c1 f9 6e fa       	vmovq  %r10,%xmm7
    fc_solve_check_and_add_state(
  40cf67:	48 8d b4 24 00 01 00 	lea    0x100(%rsp),%rsi
  40cf6e:	00 
  40cf6f:	48 8d 94 24 f0 00 00 	lea    0xf0(%rsp),%rdx
  40cf76:	00 
    instance->initial_cards_under_sequences_value = cards_under_sequences;
  40cf77:	c5 fb 11 43 08       	vmovsd %xmm0,0x8(%rbx)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  40cf7c:	48 8d 83 98 05 00 00 	lea    0x598(%rbx),%rax
  40cf83:	48 89 df             	mov    %rbx,%rdi
        pass_copy = FCS_STATE_keyval_pair_to_kv(&instance->state_copy);
  40cf86:	c4 e3 c1 22 c0 01    	vpinsrq $0x1,%rax,%xmm7,%xmm0
  40cf8c:	c5 f8 29 84 24 00 01 	vmovaps %xmm0,0x100(%rsp)
  40cf93:	00 00 
    fc_solve_check_and_add_state(
  40cf95:	e8 d6 4b ff ff       	callq  401b70 <fc_solve_check_and_add_state>
            if (HT_FIELD(hard_thread, prelude))
  40cf9a:	48 8b 83 10 05 00 00 	mov    0x510(%rbx),%rax
            HT_FIELD(hard_thread, prelude_idx) = 0;
  40cfa1:	48 c7 83 08 05 00 00 	movq   $0x0,0x508(%rbx)
  40cfa8:	00 00 00 00 
            if (HT_FIELD(hard_thread, prelude))
  40cfac:	48 85 c0             	test   %rax,%rax
  40cfaf:	74 26                	je     40cfd7 <resume_solution+0x2ce7>
        prelude[HT_FIELD(hard_thread, prelude_idx)++];
  40cfb1:	48 c7 83 08 05 00 00 	movq   $0x1,0x508(%rbx)
  40cfb8:	01 00 00 00 
    set_next_soft_thread(
  40cfbc:	48 8b 50 08          	mov    0x8(%rax),%rdx
    (*st_idx_ptr) = scan_idx;
  40cfc0:	48 8b 00             	mov    (%rax),%rax
  40cfc3:	48 89 83 d0 00 00 00 	mov    %rax,0xd0(%rbx)
        NUM_CHECKED_STATES + quota;
  40cfca:	48 8b 03             	mov    (%rbx),%rax
  40cfcd:	48 01 d0             	add    %rdx,%rax
    HT_FIELD(hard_thread, ht__max_num_checked_states) =
  40cfd0:	48 89 83 c8 00 00 00 	mov    %rax,0xc8(%rbx)
  40cfd7:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40cfde:	00 
  40cfdf:	8b 80 b8 05 00 00    	mov    0x5b8(%rax),%eax
  40cfe5:	e9 58 d3 ff ff       	jmpq   40a342 <resume_solution+0x52>
  40cfea:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  40cff0:	c4 a1 7b 10 0c dd a0 	vmovsd 0x40fda0(,%r11,8),%xmm1
  40cff7:	fd 40 00 
  40cffa:	e9 4e ff ff ff       	jmpq   40cf4d <resume_solution+0x2c5d>
  40cfff:	90                   	nop
  40d000:	48 8b 80 40 05 00 00 	mov    0x540(%rax),%rax
                return FCS_STATE_IS_NOT_SOLVEABLE;
  40d007:	41 bd 01 00 00 00    	mov    $0x1,%r13d
        if (instance->num_hard_threads_finished == NUM_HARD_THREADS())
  40d00d:	48 83 f8 01          	cmp    $0x1,%rax
  40d011:	0f 85 8a e0 ff ff    	jne    40b0a1 <resume_solution+0xdb1>
            ret = user->ret_code = flare->ret_code = resume_instance(instance);
  40d017:	48 8b bc 24 e8 00 00 	mov    0xe8(%rsp),%rdi
  40d01e:	00 
        const_AUTO(delta, flare->obj_stats.num_checked_states -
  40d01f:	48 89 f0             	mov    %rsi,%rax
  40d022:	48 2b 87 d0 05 00 00 	sub    0x5d0(%rdi),%rax
            flare->instance_is_ready = FALSE;
  40d029:	c6 87 bc 05 00 00 00 	movb   $0x0,0x5bc(%rdi)
        user->iterations_board_started_at.num_checked_states += delta;
  40d030:	48 01 87 c8 05 00 00 	add    %rax,0x5c8(%rdi)
        flare->obj_stats.num_checked_states = instance->i__num_checked_states;
  40d037:	48 89 b7 c0 05 00 00 	mov    %rsi,0x5c0(%rdi)
            ret = user->ret_code = flare->ret_code = resume_instance(instance);
  40d03e:	c7 87 b8 05 00 00 01 	movl   $0x1,0x5b8(%rdi)
  40d045:	00 00 00 
  40d048:	c7 87 38 06 00 00 01 	movl   $0x1,0x638(%rdi)
  40d04f:	00 00 00 
        user->init_num_checked_states = flare->obj_stats;
  40d052:	48 89 b7 d0 05 00 00 	mov    %rsi,0x5d0(%rdi)
    fc_solve_finish_instance(instance);
  40d059:	48 8b 9c 24 e8 00 00 	mov    0xe8(%rsp),%rbx
  40d060:	00 
  40d061:	48 89 df             	mov    %rbx,%rdi
  40d064:	e8 e7 47 ff ff       	callq  401850 <fc_solve_finish_instance>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d069:	48 8b 93 d8 00 00 00 	mov    0xd8(%rbx),%rdx
    HT_FIELD(hard_thread, ht__max_num_checked_states) = FCS_INT_LIMIT_MAX;
  40d070:	48 bf ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rdi
  40d077:	ff ff 7f 
    instance->i__num_checked_states = 0;
  40d07a:	48 c7 03 00 00 00 00 	movq   $0x0,(%rbx)
  40d081:	48 89 bb c8 00 00 00 	mov    %rdi,0xc8(%rbx)
    meta_allocator *const meta = allocator->meta;
  40d088:	48 8b bb f8 00 00 00 	mov    0xf8(%rbx),%rdi
    instance->num_hard_threads_finished = 0;
  40d08f:	48 c7 83 40 05 00 00 	movq   $0x0,0x540(%rbx)
  40d096:	00 00 00 00 
    HT_FIELD(hard_thread, num_soft_threads_finished) = 0;
  40d09a:	c7 83 28 05 00 00 00 	movl   $0x0,0x528(%rbx)
  40d0a1:	00 00 00 
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d0a4:	48 8b 02             	mov    (%rdx),%rax
    var_AUTO(bin, meta->recycle_bin);
  40d0a7:	48 8b 37             	mov    (%rdi),%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d0aa:	48 85 c0             	test   %rax,%rax
  40d0ad:	0f 85 93 02 00 00    	jne    40d346 <resume_solution+0x3056>
  40d0b3:	48 89 d0             	mov    %rdx,%rax
    var_AUTO(bin, meta->recycle_bin);
  40d0b6:	48 89 f2             	mov    %rsi,%rdx
  40d0b9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  40d0c0:	48 8b 8c 24 e8 00 00 	mov    0xe8(%rsp),%rcx
  40d0c7:	00 
    OLD_LIST_NEXT(iter) = bin;
  40d0c8:	48 89 10             	mov    %rdx,(%rax)
    meta->recycle_bin = iter;
  40d0cb:	48 89 07             	mov    %rax,(%rdi)
  40d0ce:	48 c7 81 d8 00 00 00 	movq   $0x0,0xd8(%rcx)
  40d0d5:	00 00 00 00 
    char *const ret = meta_alloc->recycle_bin;
  40d0d9:	48 8b 07             	mov    (%rdi),%rax
    if (ret)
  40d0dc:	48 85 c0             	test   %rax,%rax
  40d0df:	0f 84 d9 04 00 00    	je     40d5be <resume_solution+0x32ce>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40d0e5:	48 8b 10             	mov    (%rax),%rdx
  40d0e8:	48 89 17             	mov    %rdx,(%rdi)
        return ret;
  40d0eb:	48 8b 91 d8 00 00 00 	mov    0xd8(%rcx),%rdx
  40d0f2:	48 89 cf             	mov    %rcx,%rdi
    ST_LOOP_START()
  40d0f5:	4c 69 a7 20 05 00 00 	imul   $0x1f8,0x520(%rdi),%r12
  40d0fc:	f8 01 00 00 
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40d100:	48 89 10             	mov    %rdx,(%rax)
  40d103:	48 8b 9f c0 00 00 00 	mov    0xc0(%rdi),%rbx
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d10a:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  40d10e:	48 89 87 d8 00 00 00 	mov    %rax,0xd8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40d115:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d11b:	48 89 97 f0 00 00 00 	mov    %rdx,0xf0(%rdi)
  40d122:	48 89 97 e8 00 00 00 	mov    %rdx,0xe8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40d129:	48 89 87 e0 00 00 00 	mov    %rax,0xe0(%rdi)
  40d130:	49 01 dc             	add    %rbx,%r12
  40d133:	4c 39 e3             	cmp    %r12,%rbx
  40d136:	73 33                	jae    40d16b <resume_solution+0x2e7b>
  40d138:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40d13f:	00 
    free(pq->elems);
  40d140:	48 8b bb 00 01 00 00 	mov    0x100(%rbx),%rdi
  40d147:	48 81 c3 f8 01 00 00 	add    $0x1f8,%rbx
  40d14e:	e8 fd 3e ff ff       	callq  401050 <free@plt>
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED);
  40d153:	c6 43 e8 00          	movb   $0x0,-0x18(%rbx)
    pq->elems = NULL;
  40d157:	48 c7 83 08 ff ff ff 	movq   $0x0,-0xf8(%rbx)
  40d15e:	00 00 00 00 
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED);
  40d162:	c6 43 e9 00          	movb   $0x0,-0x17(%rbx)
  40d166:	49 39 dc             	cmp    %rbx,%r12
  40d169:	77 d5                	ja     40d140 <resume_solution+0x2e50>
                flare->instance_is_ready = TRUE;
  40d16b:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40d172:	00 
  40d173:	c6 80 bc 05 00 00 01 	movb   $0x1,0x5bc(%rax)
  40d17a:	8b 80 b8 05 00 00    	mov    0x5b8(%rax),%eax
  40d180:	e9 1c d2 ff ff       	jmpq   40a3a1 <resume_solution+0xb1>
  40d185:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40d18c:	00 00 00 00 
  40d190:	bf 18 f0 40 00       	mov    $0x40f018,%edi
  40d195:	b9 0c 00 00 00       	mov    $0xc,%ecx
  40d19a:	48 89 d6             	mov    %rdx,%rsi
  40d19d:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  40d19f:	0f 97 c0             	seta   %al
  40d1a2:	1c 00                	sbb    $0x0,%al
  40d1a4:	84 c0                	test   %al,%al
  40d1a6:	0f 85 e6 01 00 00    	jne    40d392 <resume_solution+0x30a2>
        if (new_str2)
  40d1ac:	48 89 d0             	mov    %rdx,%rax
  40d1af:	48 83 c0 0c          	add    $0xc,%rax
  40d1b3:	0f 84 d9 01 00 00    	je     40d392 <resume_solution+0x30a2>
                fcs_set_foundation(out, f_idx, 0);
  40d1b9:	41 c7 84 24 1c 06 00 	movl   $0x0,0x61c(%r12)
  40d1c0:	00 00 00 00 00 
            size_t decks_index[4] = {0, 0, 0, 0};
  40d1c5:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  40d1c9:	c5 fd 7f 84 24 00 01 	vmovdqa %ymm0,0x100(%rsp)
  40d1d0:	00 00 
                while ((*str == ' ') || (*str == '\t'))
  40d1d2:	0f b6 10             	movzbl (%rax),%edx
  40d1d5:	80 fa 20             	cmp    $0x20,%dl
  40d1d8:	0f 84 82 00 00 00    	je     40d260 <resume_solution+0x2f70>
  40d1de:	80 fa 09             	cmp    $0x9,%dl
  40d1e1:	74 7d                	je     40d260 <resume_solution+0x2f70>
                if ((*str == '\n') || (*str == '\r'))
  40d1e3:	80 fa 0a             	cmp    $0xa,%dl
  40d1e6:	0f 84 84 f9 ff ff    	je     40cb70 <resume_solution+0x2880>
  40d1ec:	80 fa 0d             	cmp    $0xd,%dl
  40d1ef:	0f 84 7b f9 ff ff    	je     40cb70 <resume_solution+0x2880>
  40d1f5:	48 89 c1             	mov    %rax,%rcx
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d1f8:	0f b6 11             	movzbl (%rcx),%edx
  40d1fb:	80 fa 43             	cmp    $0x43,%dl
  40d1fe:	74 25                	je     40d225 <resume_solution+0x2f35>
  40d200:	7e 6e                	jle    40d270 <resume_solution+0x2f80>
  40d202:	80 fa 48             	cmp    $0x48,%dl
  40d205:	74 72                	je     40d279 <resume_solution+0x2f89>
  40d207:	80 fa 53             	cmp    $0x53,%dl
  40d20a:	0f 84 20 01 00 00    	je     40d330 <resume_solution+0x3040>
  40d210:	80 fa 44             	cmp    $0x44,%dl
  40d213:	0f 84 07 01 00 00    	je     40d320 <resume_solution+0x3030>
            ++suit;
  40d219:	48 83 c1 01          	add    $0x1,%rcx
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d21d:	0f b6 11             	movzbl (%rcx),%edx
  40d220:	80 fa 43             	cmp    $0x43,%dl
  40d223:	75 db                	jne    40d200 <resume_solution+0x2f10>
                ++str;
  40d225:	48 8d 50 01          	lea    0x1(%rax),%rdx
                while (*str == '-')
  40d229:	0f b6 40 01          	movzbl 0x1(%rax),%eax
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d22d:	be 01 00 00 00       	mov    $0x1,%esi
            return 1;
  40d232:	b9 01 00 00 00       	mov    $0x1,%ecx
                while (*str == '-')
  40d237:	3c 2d                	cmp    $0x2d,%al
  40d239:	74 55                	je     40d290 <resume_solution+0x2fa0>
                const int c = ((str[0] == '0') ? 0 : fcs_str2rank(str));
  40d23b:	3c 30                	cmp    $0x30,%al
  40d23d:	74 60                	je     40d29f <resume_solution+0x2faf>
  40d23f:	90                   	nop
  40d240:	48 89 d7             	mov    %rdx,%rdi
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d243:	80 3f 54             	cmpb   $0x54,(%rdi)
  40d246:	0f 87 f9 05 00 00    	ja     40d845 <resume_solution+0x3555>
  40d24c:	44 0f b6 2f          	movzbl (%rdi),%r13d
  40d250:	42 ff 24 ed 88 f4 40 	jmpq   *0x40f488(,%r13,8)
  40d257:	00 
  40d258:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40d25f:	00 
                    ++str;
  40d260:	48 83 c0 01          	add    $0x1,%rax
  40d264:	e9 69 ff ff ff       	jmpq   40d1d2 <resume_solution+0x2ee2>
  40d269:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  40d270:	84 d2                	test   %dl,%dl
  40d272:	74 05                	je     40d279 <resume_solution+0x2f89>
  40d274:	80 fa 20             	cmp    $0x20,%dl
  40d277:	75 a0                	jne    40d219 <resume_solution+0x2f29>
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d279:	31 f6                	xor    %esi,%esi
            return 0;
  40d27b:	31 c9                	xor    %ecx,%ecx
                ++str;
  40d27d:	48 8d 50 01          	lea    0x1(%rax),%rdx
                while (*str == '-')
  40d281:	0f b6 40 01          	movzbl 0x1(%rax),%eax
  40d285:	3c 2d                	cmp    $0x2d,%al
  40d287:	75 b2                	jne    40d23b <resume_solution+0x2f4b>
  40d289:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
                    ++str;
  40d290:	48 83 c2 01          	add    $0x1,%rdx
                while (*str == '-')
  40d294:	0f b6 02             	movzbl (%rdx),%eax
  40d297:	3c 2d                	cmp    $0x2d,%al
  40d299:	74 f5                	je     40d290 <resume_solution+0x2fa0>
                const int c = ((str[0] == '0') ? 0 : fcs_str2rank(str));
  40d29b:	3c 30                	cmp    $0x30,%al
  40d29d:	75 a1                	jne    40d240 <resume_solution+0x2f50>
  40d29f:	31 ff                	xor    %edi,%edi
  40d2a1:	eb 15                	jmp    40d2b8 <resume_solution+0x2fc8>
  40d2a3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40d2aa:	00 00 00 00 
  40d2ae:	66 90                	xchg   %ax,%ax
                    HANDLE_EOS();
  40d2b0:	84 c0                	test   %al,%al
  40d2b2:	0f 84 88 f8 ff ff    	je     40cb40 <resume_solution+0x2850>
                    ++str;
  40d2b8:	48 83 c2 01          	add    $0x1,%rdx
                while ((*str != ' ') && (*str != '\t') && (*str != '\n') &&
  40d2bc:	0f b6 02             	movzbl (%rdx),%eax
  40d2bf:	3c 20                	cmp    $0x20,%al
  40d2c1:	77 ed                	ja     40d2b0 <resume_solution+0x2fc0>
  40d2c3:	49 0f a3 c1          	bt     %rax,%r9
  40d2c7:	73 e7                	jae    40d2b0 <resume_solution+0x2fc0>
                fcs_set_foundation(out, ((decks_index[f_idx] << 2) + f_idx), c);
  40d2c9:	48 8b 84 cc 00 01 00 	mov    0x100(%rsp,%rcx,8),%rax
  40d2d0:	00 
  40d2d1:	4c 01 e6             	add    %r12,%rsi
                    decks_index[f_idx] = 0;
  40d2d4:	48 c7 84 cc 00 01 00 	movq   $0x0,0x100(%rsp,%rcx,8)
  40d2db:	00 00 00 00 00 
                fcs_set_foundation(out, ((decks_index[f_idx] << 2) + f_idx), c);
  40d2e0:	40 88 bc 86 1c 06 00 	mov    %dil,0x61c(%rsi,%rax,4)
  40d2e7:	00 
                    decks_index[f_idx] = 0;
  40d2e8:	48 89 d0             	mov    %rdx,%rax
  40d2eb:	e9 e2 fe ff ff       	jmpq   40d1d2 <resume_solution+0x2ee2>
  40d2f0:	48 8b bc 24 e8 00 00 	mov    0xe8(%rsp),%rdi
  40d2f7:	00 
  40d2f8:	48 8b 37             	mov    (%rdi),%rsi
  40d2fb:	e9 97 dd ff ff       	jmpq   40b097 <resume_solution+0xda7>
                    if ((*str == '\n') || (*str == '\r'))
  40d300:	80 fa 0a             	cmp    $0xa,%dl
  40d303:	0f 84 5f f8 ff ff    	je     40cb68 <resume_solution+0x2878>
  40d309:	80 fa 0d             	cmp    $0xd,%dl
  40d30c:	0f 84 56 f8 ff ff    	je     40cb68 <resume_solution+0x2878>
                    ++str;
  40d312:	48 83 c0 01          	add    $0x1,%rax
  40d316:	e9 8e f7 ff ff       	jmpq   40caa9 <resume_solution+0x27b9>
  40d31b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d320:	be 02 00 00 00       	mov    $0x2,%esi
            return 2;
  40d325:	b9 02 00 00 00       	mov    $0x2,%ecx
  40d32a:	e9 4e ff ff ff       	jmpq   40d27d <resume_solution+0x2f8d>
  40d32f:	90                   	nop
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d330:	be 03 00 00 00       	mov    $0x3,%esi
            return 3;
  40d335:	b9 03 00 00 00       	mov    $0x3,%ecx
  40d33a:	e9 3e ff ff ff       	jmpq   40d27d <resume_solution+0x2f8d>
  40d33f:	90                   	nop
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d340:	48 89 c2             	mov    %rax,%rdx
  40d343:	48 89 c8             	mov    %rcx,%rax
        OLD_LIST_NEXT(iter) = bin;
  40d346:	48 89 32             	mov    %rsi,(%rdx)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  40d349:	48 8b 08             	mov    (%rax),%rcx
  40d34c:	48 89 d6             	mov    %rdx,%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d34f:	48 85 c9             	test   %rcx,%rcx
  40d352:	75 ec                	jne    40d340 <resume_solution+0x3050>
  40d354:	e9 67 fd ff ff       	jmpq   40d0c0 <resume_solution+0x2dd0>
  40d359:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            if (was_run_now)
  40d360:	41 83 fd 01          	cmp    $0x1,%r13d
  40d364:	0f 85 8b d0 ff ff    	jne    40a3f5 <resume_solution+0x105>
  40d36a:	e9 ea fc ff ff       	jmpq   40d059 <resume_solution+0x2d69>
  40d36f:	90                   	nop
  40d370:	b9 0c 00 00 00       	mov    $0xc,%ecx
  40d375:	bf 18 f0 40 00       	mov    $0x40f018,%edi
  40d37a:	48 89 de             	mov    %rbx,%rsi
  40d37d:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  40d37f:	b8 02 00 00 00       	mov    $0x2,%eax
  40d384:	0f 97 c1             	seta   %cl
  40d387:	80 d9 00             	sbb    $0x0,%cl
  40d38a:	84 c9                	test   %cl,%cl
  40d38c:	0f 84 27 fe ff ff    	je     40d1b9 <resume_solution+0x2ec9>
        if ((*str) == ':')
  40d392:	0f b6 02             	movzbl (%rdx),%eax
  40d395:	3c 3a                	cmp    $0x3a,%al
  40d397:	0f 84 1c 01 00 00    	je     40d4b9 <resume_solution+0x31c9>
        var_AUTO(col, fcs_state_get_col(out, s));
  40d39d:	4b 8b bc d4 d8 05 00 	mov    0x5d8(%r12,%r10,8),%rdi
  40d3a4:	00 
  40d3a5:	be 14 00 00 00       	mov    $0x14,%esi
            while ((*str == ' ') || (*str == '\t'))
  40d3aa:	3c 09                	cmp    $0x9,%al
  40d3ac:	74 12                	je     40d3c0 <resume_solution+0x30d0>
  40d3ae:	3c 20                	cmp    $0x20,%al
  40d3b0:	75 1d                	jne    40d3cf <resume_solution+0x30df>
  40d3b2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40d3b9:	00 00 00 00 
  40d3bd:	0f 1f 00             	nopl   (%rax)
                ++str;
  40d3c0:	48 83 c2 01          	add    $0x1,%rdx
            while ((*str == ' ') || (*str == '\t'))
  40d3c4:	0f b6 02             	movzbl (%rdx),%eax
  40d3c7:	3c 20                	cmp    $0x20,%al
  40d3c9:	74 f5                	je     40d3c0 <resume_solution+0x30d0>
  40d3cb:	3c 09                	cmp    $0x9,%al
  40d3cd:	74 f1                	je     40d3c0 <resume_solution+0x30d0>
            HANDLE_EOS();
  40d3cf:	84 c0                	test   %al,%al
  40d3d1:	0f 84 69 f7 ff ff    	je     40cb40 <resume_solution+0x2850>
            if ((*str == '\n') || (*str == '\r'))
  40d3d7:	3c 0a                	cmp    $0xa,%al
  40d3d9:	0f 84 91 00 00 00    	je     40d470 <resume_solution+0x3180>
  40d3df:	3c 0d                	cmp    $0xd,%al
  40d3e1:	0f 84 89 00 00 00    	je     40d470 <resume_solution+0x3180>
  40d3e7:	48 89 d1             	mov    %rdx,%rcx
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d3ea:	0f b6 01             	movzbl (%rcx),%eax
  40d3ed:	3c 43                	cmp    $0x43,%al
  40d3ef:	74 19                	je     40d40a <resume_solution+0x311a>
  40d3f1:	7e 3d                	jle    40d430 <resume_solution+0x3140>
  40d3f3:	3c 48                	cmp    $0x48,%al
  40d3f5:	74 41                	je     40d438 <resume_solution+0x3148>
  40d3f7:	3c 53                	cmp    $0x53,%al
  40d3f9:	74 55                	je     40d450 <resume_solution+0x3160>
  40d3fb:	3c 44                	cmp    $0x44,%al
  40d3fd:	74 41                	je     40d440 <resume_solution+0x3150>
            ++suit;
  40d3ff:	48 83 c1 01          	add    $0x1,%rcx
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d403:	0f b6 01             	movzbl (%rcx),%eax
  40d406:	3c 43                	cmp    $0x43,%al
  40d408:	75 e7                	jne    40d3f1 <resume_solution+0x3101>
  40d40a:	b8 01 00 00 00       	mov    $0x1,%eax
  40d40f:	90                   	nop
  40d410:	48 89 d1             	mov    %rdx,%rcx
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d413:	80 39 54             	cmpb   $0x54,(%rcx)
  40d416:	0f 87 e3 02 00 00    	ja     40d6ff <resume_solution+0x340f>
  40d41c:	44 0f b6 29          	movzbl (%rcx),%r13d
  40d420:	42 ff 24 ed 30 f7 40 	jmpq   *0x40f730(,%r13,8)
  40d427:	00 
  40d428:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40d42f:	00 
  40d430:	84 c0                	test   %al,%al
  40d432:	74 04                	je     40d438 <resume_solution+0x3148>
  40d434:	3c 20                	cmp    $0x20,%al
  40d436:	75 c7                	jne    40d3ff <resume_solution+0x310f>
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d438:	31 c0                	xor    %eax,%eax
  40d43a:	eb d4                	jmp    40d410 <resume_solution+0x3120>
  40d43c:	0f 1f 40 00          	nopl   0x0(%rax)
  40d440:	b8 02 00 00 00       	mov    $0x2,%eax
  40d445:	eb c9                	jmp    40d410 <resume_solution+0x3120>
  40d447:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40d44e:	00 00 
  40d450:	b8 03 00 00 00       	mov    $0x3,%eax
  40d455:	eb b9                	jmp    40d410 <resume_solution+0x3120>
                if ((*str == '\n') || (*str == '\r'))
  40d457:	3c 0a                	cmp    $0xa,%al
  40d459:	74 15                	je     40d470 <resume_solution+0x3180>
  40d45b:	3c 0d                	cmp    $0xd,%al
  40d45d:	0f 85 47 ff ff ff    	jne    40d3aa <resume_solution+0x30ba>
  40d463:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40d46a:	00 00 00 00 
  40d46e:	66 90                	xchg   %ax,%ax
  40d470:	49 83 c2 01          	add    $0x1,%r10
                       ((*str) != '\n') && ((*str) != '\r'))
  40d474:	48 89 d0             	mov    %rdx,%rax
  40d477:	e9 f4 f6 ff ff       	jmpq   40cb70 <resume_solution+0x2880>
  40d47c:	0f 1f 40 00          	nopl   0x0(%rax)
        return malloc(ALLOCED_SIZE);
  40d480:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40d485:	e8 66 3c ff ff       	callq  4010f0 <malloc@plt>
  40d48a:	31 d2                	xor    %edx,%edx
  40d48c:	e9 92 f9 ff ff       	jmpq   40ce23 <resume_solution+0x2b33>
  40d491:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40d498:	00 00 00 00 
  40d49c:	0f 1f 40 00          	nopl   0x0(%rax)
  40d4a0:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40d4a5:	e8 46 3c ff ff       	callq  4010f0 <malloc@plt>
  40d4aa:	31 d2                	xor    %edx,%edx
  40d4ac:	4c 8b b4 24 e8 00 00 	mov    0xe8(%rsp),%r14
  40d4b3:	00 
  40d4b4:	e9 eb f8 ff ff       	jmpq   40cda4 <resume_solution+0x2ab4>
            ++str;
  40d4b9:	0f b6 42 01          	movzbl 0x1(%rdx),%eax
  40d4bd:	48 83 c2 01          	add    $0x1,%rdx
  40d4c1:	e9 d7 fe ff ff       	jmpq   40d39d <resume_solution+0x30ad>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d4c6:	41 be 30 00 00 00    	mov    $0x30,%r14d
  40d4cc:	0f 1f 40 00          	nopl   0x0(%rax)
            fcs_col_push_card(col, my_card);
  40d4d0:	48 0f be 0f          	movsbq (%rdi),%rcx
    return (fcs_card)((((fcs_card)rank) << 2) | ((fcs_card)suit));
  40d4d4:	44 09 f0             	or     %r14d,%eax
            fcs_col_push_card(col, my_card);
  40d4d7:	44 8d 69 01          	lea    0x1(%rcx),%r13d
  40d4db:	44 88 2f             	mov    %r13b,(%rdi)
    return (fcs_card)((((fcs_card)rank) << 2) | ((fcs_card)suit));
  40d4de:	88 44 0f 01          	mov    %al,0x1(%rdi,%rcx,1)
        for (int c = 0; c < MAX_NUM_CARDS_IN_A_STACK; c++)
  40d4e2:	83 ee 01             	sub    $0x1,%esi
  40d4e5:	74 89                	je     40d470 <resume_solution+0x3180>
                while (((*str) != ' ') && ((*str) != '\t') &&
  40d4e7:	0f b6 02             	movzbl (%rdx),%eax
  40d4ea:	3c 09                	cmp    $0x9,%al
  40d4ec:	0f 84 65 ff ff ff    	je     40d457 <resume_solution+0x3167>
  40d4f2:	3c 20                	cmp    $0x20,%al
  40d4f4:	0f 84 5d ff ff ff    	je     40d457 <resume_solution+0x3167>
                       ((*str) != '\n') && ((*str) != '\r'))
  40d4fa:	3c 0d                	cmp    $0xd,%al
  40d4fc:	0f 84 6e ff ff ff    	je     40d470 <resume_solution+0x3180>
  40d502:	3c 0a                	cmp    $0xa,%al
  40d504:	75 31                	jne    40d537 <resume_solution+0x3247>
  40d506:	e9 65 ff ff ff       	jmpq   40d470 <resume_solution+0x3180>
  40d50b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
                    ++str;
  40d510:	48 83 c2 01          	add    $0x1,%rdx
                while (((*str) != ' ') && ((*str) != '\t') &&
  40d514:	0f b6 02             	movzbl (%rdx),%eax
  40d517:	3c 20                	cmp    $0x20,%al
  40d519:	0f 84 38 ff ff ff    	je     40d457 <resume_solution+0x3167>
  40d51f:	3c 09                	cmp    $0x9,%al
  40d521:	0f 84 30 ff ff ff    	je     40d457 <resume_solution+0x3167>
                       ((*str) != '\n') && ((*str) != '\r'))
  40d527:	3c 0a                	cmp    $0xa,%al
  40d529:	0f 84 41 ff ff ff    	je     40d470 <resume_solution+0x3180>
  40d52f:	3c 0d                	cmp    $0xd,%al
  40d531:	0f 84 39 ff ff ff    	je     40d470 <resume_solution+0x3180>
                    HANDLE_EOS();
  40d537:	84 c0                	test   %al,%al
  40d539:	75 d5                	jne    40d510 <resume_solution+0x3220>
  40d53b:	e9 00 f6 ff ff       	jmpq   40cb40 <resume_solution+0x2850>
        case 'K':
  40d540:	41 be 34 00 00 00    	mov    $0x34,%r14d
  40d546:	eb 88                	jmp    40d4d0 <resume_solution+0x31e0>
        case 'T':
  40d548:	41 be 28 00 00 00    	mov    $0x28,%r14d
  40d54e:	eb 80                	jmp    40d4d0 <resume_solution+0x31e0>
        case '8':
  40d550:	41 be 20 00 00 00    	mov    $0x20,%r14d
  40d556:	e9 75 ff ff ff       	jmpq   40d4d0 <resume_solution+0x31e0>
        case '9':
  40d55b:	41 be 24 00 00 00    	mov    $0x24,%r14d
  40d561:	e9 6a ff ff ff       	jmpq   40d4d0 <resume_solution+0x31e0>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d566:	41 be 04 00 00 00    	mov    $0x4,%r14d
  40d56c:	e9 5f ff ff ff       	jmpq   40d4d0 <resume_solution+0x31e0>
  40d571:	41 be 2c 00 00 00    	mov    $0x2c,%r14d
  40d577:	e9 54 ff ff ff       	jmpq   40d4d0 <resume_solution+0x31e0>
        case '3':
  40d57c:	41 be 0c 00 00 00    	mov    $0xc,%r14d
  40d582:	e9 49 ff ff ff       	jmpq   40d4d0 <resume_solution+0x31e0>
        case '4':
  40d587:	41 be 10 00 00 00    	mov    $0x10,%r14d
  40d58d:	e9 3e ff ff ff       	jmpq   40d4d0 <resume_solution+0x31e0>
        case '5':
  40d592:	41 be 14 00 00 00    	mov    $0x14,%r14d
  40d598:	e9 33 ff ff ff       	jmpq   40d4d0 <resume_solution+0x31e0>
        case '6':
  40d59d:	41 be 18 00 00 00    	mov    $0x18,%r14d
  40d5a3:	e9 28 ff ff ff       	jmpq   40d4d0 <resume_solution+0x31e0>
        case '2':
  40d5a8:	41 be 08 00 00 00    	mov    $0x8,%r14d
  40d5ae:	e9 1d ff ff ff       	jmpq   40d4d0 <resume_solution+0x31e0>
        case '7':
  40d5b3:	41 be 1c 00 00 00    	mov    $0x1c,%r14d
  40d5b9:	e9 12 ff ff ff       	jmpq   40d4d0 <resume_solution+0x31e0>
  40d5be:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40d5c3:	e8 28 3b ff ff       	callq  4010f0 <malloc@plt>
  40d5c8:	31 d2                	xor    %edx,%edx
  40d5ca:	48 8b bc 24 e8 00 00 	mov    0xe8(%rsp),%rdi
  40d5d1:	00 
  40d5d2:	e9 1e fb ff ff       	jmpq   40d0f5 <resume_solution+0x2e05>
    fc_solve_finish_instance(instance);
  40d5d7:	48 89 c3             	mov    %rax,%rbx
  40d5da:	48 89 c7             	mov    %rax,%rdi
  40d5dd:	e8 6e 42 ff ff       	callq  401850 <fc_solve_finish_instance>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d5e2:	48 8b 83 d8 00 00 00 	mov    0xd8(%rbx),%rax
    HT_FIELD(hard_thread, ht__max_num_checked_states) = FCS_INT_LIMIT_MAX;
  40d5e9:	48 bf ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rdi
  40d5f0:	ff ff 7f 
    instance->i__num_checked_states = 0;
  40d5f3:	48 c7 03 00 00 00 00 	movq   $0x0,(%rbx)
  40d5fa:	48 89 bb c8 00 00 00 	mov    %rdi,0xc8(%rbx)
    meta_allocator *const meta = allocator->meta;
  40d601:	48 8b bb f8 00 00 00 	mov    0xf8(%rbx),%rdi
    instance->num_hard_threads_finished = 0;
  40d608:	48 c7 83 40 05 00 00 	movq   $0x0,0x540(%rbx)
  40d60f:	00 00 00 00 
    HT_FIELD(hard_thread, num_soft_threads_finished) = 0;
  40d613:	c7 83 28 05 00 00 00 	movl   $0x0,0x528(%rbx)
  40d61a:	00 00 00 
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d61d:	48 8b 10             	mov    (%rax),%rdx
    var_AUTO(bin, meta->recycle_bin);
  40d620:	48 8b 37             	mov    (%rdi),%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d623:	48 85 d2             	test   %rdx,%rdx
  40d626:	75 0e                	jne    40d636 <resume_solution+0x3346>
  40d628:	e9 84 02 00 00       	jmpq   40d8b1 <resume_solution+0x35c1>
  40d62d:	0f 1f 00             	nopl   (%rax)
  40d630:	48 89 d0             	mov    %rdx,%rax
  40d633:	48 89 ca             	mov    %rcx,%rdx
        OLD_LIST_NEXT(iter) = bin;
  40d636:	48 89 30             	mov    %rsi,(%rax)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  40d639:	48 8b 0a             	mov    (%rdx),%rcx
  40d63c:	48 89 c6             	mov    %rax,%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d63f:	48 85 c9             	test   %rcx,%rcx
  40d642:	75 ec                	jne    40d630 <resume_solution+0x3340>
  40d644:	48 8b 8c 24 e8 00 00 	mov    0xe8(%rsp),%rcx
  40d64b:	00 
    OLD_LIST_NEXT(iter) = bin;
  40d64c:	48 89 02             	mov    %rax,(%rdx)
    meta->recycle_bin = iter;
  40d64f:	48 89 17             	mov    %rdx,(%rdi)
  40d652:	48 c7 81 d8 00 00 00 	movq   $0x0,0xd8(%rcx)
  40d659:	00 00 00 00 
    char *const ret = meta_alloc->recycle_bin;
  40d65d:	48 8b 07             	mov    (%rdi),%rax
    if (ret)
  40d660:	48 85 c0             	test   %rax,%rax
  40d663:	0f 84 2f 02 00 00    	je     40d898 <resume_solution+0x35a8>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40d669:	48 8b 10             	mov    (%rax),%rdx
  40d66c:	48 89 17             	mov    %rdx,(%rdi)
        return ret;
  40d66f:	48 8b 91 d8 00 00 00 	mov    0xd8(%rcx),%rdx
  40d676:	48 89 cf             	mov    %rcx,%rdi
    ST_LOOP_START()
  40d679:	4c 69 a7 20 05 00 00 	imul   $0x1f8,0x520(%rdi),%r12
  40d680:	f8 01 00 00 
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40d684:	48 89 10             	mov    %rdx,(%rax)
  40d687:	48 8b 9f c0 00 00 00 	mov    0xc0(%rdi),%rbx
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d68e:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  40d692:	48 89 87 d8 00 00 00 	mov    %rax,0xd8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40d699:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d69f:	48 89 97 f0 00 00 00 	mov    %rdx,0xf0(%rdi)
  40d6a6:	48 89 97 e8 00 00 00 	mov    %rdx,0xe8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40d6ad:	48 89 87 e0 00 00 00 	mov    %rax,0xe0(%rdi)
  40d6b4:	49 01 dc             	add    %rbx,%r12
  40d6b7:	4c 39 e3             	cmp    %r12,%rbx
  40d6ba:	73 2f                	jae    40d6eb <resume_solution+0x33fb>
  40d6bc:	0f 1f 40 00          	nopl   0x0(%rax)
    free(pq->elems);
  40d6c0:	48 8b bb 00 01 00 00 	mov    0x100(%rbx),%rdi
  40d6c7:	48 81 c3 f8 01 00 00 	add    $0x1f8,%rbx
  40d6ce:	e8 7d 39 ff ff       	callq  401050 <free@plt>
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED);
  40d6d3:	c6 43 e8 00          	movb   $0x0,-0x18(%rbx)
    pq->elems = NULL;
  40d6d7:	48 c7 83 08 ff ff ff 	movq   $0x0,-0xf8(%rbx)
  40d6de:	00 00 00 00 
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED);
  40d6e2:	c6 43 e9 00          	movb   $0x0,-0x17(%rbx)
  40d6e6:	49 39 dc             	cmp    %rbx,%r12
  40d6e9:	77 d5                	ja     40d6c0 <resume_solution+0x33d0>
        flare->instance_is_ready = TRUE;
  40d6eb:	48 8b 84 24 e8 00 00 	mov    0xe8(%rsp),%rax
  40d6f2:	00 
  40d6f3:	c6 80 bc 05 00 00 01 	movb   $0x1,0x5bc(%rax)
  40d6fa:	e9 c8 cc ff ff       	jmpq   40a3c7 <resume_solution+0xd7>
            ++string;
  40d6ff:	48 83 c1 01          	add    $0x1,%rcx
  40d703:	e9 0b fd ff ff       	jmpq   40d413 <resume_solution+0x3123>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d708:	31 ff                	xor    %edi,%edi
                while ((*str != ' ') && (*str != '\t') && (*str != '\n') &&
  40d70a:	e9 b0 fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case 'Q':
  40d70f:	bf 0c 00 00 00       	mov    $0xc,%edi
  40d714:	e9 a6 fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case 'J':
  40d719:	bf 0b 00 00 00       	mov    $0xb,%edi
  40d71e:	e9 9c fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case 'K':
  40d723:	bf 0d 00 00 00       	mov    $0xd,%edi
  40d728:	e9 92 fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case '7':
  40d72d:	bf 07 00 00 00       	mov    $0x7,%edi
  40d732:	e9 88 fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case '8':
  40d737:	bf 08 00 00 00       	mov    $0x8,%edi
  40d73c:	e9 7e fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case '9':
  40d741:	bf 09 00 00 00       	mov    $0x9,%edi
  40d746:	e9 74 fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d74b:	bf 01 00 00 00       	mov    $0x1,%edi
  40d750:	e9 6a fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case 'T':
  40d755:	bf 0a 00 00 00       	mov    $0xa,%edi
  40d75a:	e9 60 fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case '2':
  40d75f:	bf 02 00 00 00       	mov    $0x2,%edi
  40d764:	e9 56 fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case '3':
  40d769:	bf 03 00 00 00       	mov    $0x3,%edi
  40d76e:	e9 4c fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case '4':
  40d773:	bf 04 00 00 00       	mov    $0x4,%edi
  40d778:	e9 42 fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case '5':
  40d77d:	bf 05 00 00 00       	mov    $0x5,%edi
  40d782:	e9 38 fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        case '6':
  40d787:	bf 06 00 00 00       	mov    $0x6,%edi
  40d78c:	e9 2e fb ff ff       	jmpq   40d2bf <resume_solution+0x2fcf>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d791:	ba 30 00 00 00       	mov    $0x30,%edx
  40d796:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40d79d:	00 00 00 
                fcs_put_card_in_freecell(out, c,
  40d7a0:	48 89 c7             	mov    %rax,%rdi
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d7a3:	0f b6 37             	movzbl (%rdi),%esi
  40d7a6:	40 80 fe 43          	cmp    $0x43,%sil
  40d7aa:	74 31                	je     40d7dd <resume_solution+0x34ed>
  40d7ac:	0f 8e ae 00 00 00    	jle    40d860 <resume_solution+0x3570>
  40d7b2:	40 80 fe 48          	cmp    $0x48,%sil
  40d7b6:	0f 84 37 f3 ff ff    	je     40caf3 <resume_solution+0x2803>
  40d7bc:	40 80 fe 53          	cmp    $0x53,%sil
  40d7c0:	0f 84 ca 00 00 00    	je     40d890 <resume_solution+0x35a0>
  40d7c6:	40 80 fe 44          	cmp    $0x44,%sil
  40d7ca:	0f 84 b0 00 00 00    	je     40d880 <resume_solution+0x3590>
            ++suit;
  40d7d0:	48 83 c7 01          	add    $0x1,%rdi
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d7d4:	0f b6 37             	movzbl (%rdi),%esi
  40d7d7:	40 80 fe 43          	cmp    $0x43,%sil
  40d7db:	75 cf                	jne    40d7ac <resume_solution+0x34bc>
            return 1;
  40d7dd:	83 ca 01             	or     $0x1,%edx
  40d7e0:	e9 0e f3 ff ff       	jmpq   40caf3 <resume_solution+0x2803>
        case '3':
  40d7e5:	ba 0c 00 00 00       	mov    $0xc,%edx
  40d7ea:	eb b4                	jmp    40d7a0 <resume_solution+0x34b0>
        case '4':
  40d7ec:	ba 10 00 00 00       	mov    $0x10,%edx
  40d7f1:	eb ad                	jmp    40d7a0 <resume_solution+0x34b0>
        case '5':
  40d7f3:	ba 14 00 00 00       	mov    $0x14,%edx
  40d7f8:	eb a6                	jmp    40d7a0 <resume_solution+0x34b0>
        case '6':
  40d7fa:	ba 18 00 00 00       	mov    $0x18,%edx
  40d7ff:	eb 9f                	jmp    40d7a0 <resume_solution+0x34b0>
        case '7':
  40d801:	ba 1c 00 00 00       	mov    $0x1c,%edx
  40d806:	eb 98                	jmp    40d7a0 <resume_solution+0x34b0>
        case '8':
  40d808:	ba 20 00 00 00       	mov    $0x20,%edx
  40d80d:	eb 91                	jmp    40d7a0 <resume_solution+0x34b0>
        case '9':
  40d80f:	ba 24 00 00 00       	mov    $0x24,%edx
  40d814:	eb 8a                	jmp    40d7a0 <resume_solution+0x34b0>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d816:	ba 04 00 00 00       	mov    $0x4,%edx
  40d81b:	eb 83                	jmp    40d7a0 <resume_solution+0x34b0>
  40d81d:	ba 2c 00 00 00       	mov    $0x2c,%edx
  40d822:	e9 79 ff ff ff       	jmpq   40d7a0 <resume_solution+0x34b0>
        case 'T':
  40d827:	ba 28 00 00 00       	mov    $0x28,%edx
  40d82c:	e9 6f ff ff ff       	jmpq   40d7a0 <resume_solution+0x34b0>
        case 'K':
  40d831:	ba 34 00 00 00       	mov    $0x34,%edx
  40d836:	e9 65 ff ff ff       	jmpq   40d7a0 <resume_solution+0x34b0>
        case '2':
  40d83b:	ba 08 00 00 00       	mov    $0x8,%edx
  40d840:	e9 5b ff ff ff       	jmpq   40d7a0 <resume_solution+0x34b0>
            ++string;
  40d845:	48 83 c7 01          	add    $0x1,%rdi
  40d849:	e9 f5 f9 ff ff       	jmpq   40d243 <resume_solution+0x2f53>
  40d84e:	48 83 c2 01          	add    $0x1,%rdx
  40d852:	e9 4c f3 ff ff       	jmpq   40cba3 <resume_solution+0x28b3>
  40d857:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40d85e:	00 00 
  40d860:	40 84 f6             	test   %sil,%sil
  40d863:	0f 84 8a f2 ff ff    	je     40caf3 <resume_solution+0x2803>
  40d869:	40 80 fe 20          	cmp    $0x20,%sil
  40d86d:	0f 85 5d ff ff ff    	jne    40d7d0 <resume_solution+0x34e0>
  40d873:	e9 7b f2 ff ff       	jmpq   40caf3 <resume_solution+0x2803>
  40d878:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40d87f:	00 
            return 2;
  40d880:	83 ca 02             	or     $0x2,%edx
  40d883:	e9 6b f2 ff ff       	jmpq   40caf3 <resume_solution+0x2803>
  40d888:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40d88f:	00 
            return 3;
  40d890:	83 ca 03             	or     $0x3,%edx
  40d893:	e9 5b f2 ff ff       	jmpq   40caf3 <resume_solution+0x2803>
        return malloc(ALLOCED_SIZE);
  40d898:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40d89d:	e8 4e 38 ff ff       	callq  4010f0 <malloc@plt>
  40d8a2:	31 d2                	xor    %edx,%edx
  40d8a4:	48 8b bc 24 e8 00 00 	mov    0xe8(%rsp),%rdi
  40d8ab:	00 
  40d8ac:	e9 c8 fd ff ff       	jmpq   40d679 <resume_solution+0x3389>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d8b1:	48 89 c2             	mov    %rax,%rdx
    var_AUTO(bin, meta->recycle_bin);
  40d8b4:	48 89 f0             	mov    %rsi,%rax
  40d8b7:	e9 88 fd ff ff       	jmpq   40d644 <resume_solution+0x3354>
  40d8bc:	4c 89 ef             	mov    %r13,%rdi
  40d8bf:	48 c1 e7 04          	shl    $0x4,%rdi
  40d8c3:	e9 25 dd ff ff       	jmpq   40b5ed <resume_solution+0x12fd>
  40d8c8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40d8cf:	00 

000000000040d8d0 <worker_thread>:
{
  40d8d0:	55                   	push   %rbp
    fcs_user *const ret = (fcs_user *)SMALLOC1(ret);
  40d8d1:	bf 50 12 00 00       	mov    $0x1250,%edi
  40d8d6:	48 89 e5             	mov    %rsp,%rbp
  40d8d9:	41 57                	push   %r15
  40d8db:	41 56                	push   %r14
  40d8dd:	41 55                	push   %r13
  40d8df:	41 54                	push   %r12
  40d8e1:	53                   	push   %rbx
  40d8e2:	48 83 e4 e0          	and    $0xffffffffffffffe0,%rsp
  40d8e6:	48 81 ec 80 02 00 00 	sub    $0x280,%rsp
  40d8ed:	e8 fe 37 ff ff       	callq  4010f0 <malloc@plt>
    *(instance) = (fcs_instance){
  40d8f2:	ba b8 05 00 00       	mov    $0x5b8,%edx
  40d8f7:	31 f6                	xor    %esi,%esi
    fcs_user *const ret = (fcs_user *)SMALLOC1(ret);
  40d8f9:	49 89 c6             	mov    %rax,%r14
    *(instance) = (fcs_instance){
  40d8fc:	48 89 c7             	mov    %rax,%rdi
    meta->recycle_bin = NULL;
  40d8ff:	48 c7 80 48 12 00 00 	movq   $0x0,0x1248(%rax)
  40d906:	00 00 00 00 
    user->iterations_board_started_at = initial_stats;
  40d90a:	48 c7 80 c8 05 00 00 	movq   $0x0,0x5c8(%rax)
  40d911:	00 00 00 00 
    *(instance) = (fcs_instance){
  40d915:	e8 86 37 ff ff       	callq  4010a0 <memset@plt>
    alloc_instance(instance, &(user->meta_alloc));
  40d91a:	49 8d 86 48 12 00 00 	lea    0x1248(%r14),%rax
    fc_solve_apply_moves_order(&(instance->instance_moves_order),
  40d921:	be 25 f0 40 00       	mov    $0x40f025,%esi
    *(instance) = (fcs_instance){
  40d926:	41 c6 86 b8 00 00 00 	movb   $0x1,0xb8(%r14)
  40d92d:	01 
    fc_solve_apply_moves_order(&(instance->instance_moves_order),
  40d92e:	49 8d be 30 05 00 00 	lea    0x530(%r14),%rdi
    alloc_instance(instance, &(user->meta_alloc));
  40d935:	49 89 86 b0 05 00 00 	mov    %rax,0x5b0(%r14)
    fc_solve_apply_moves_order(&(instance->instance_moves_order),
  40d93c:	e8 3f c2 ff ff       	callq  409b80 <fc_solve_apply_moves_order>
    fc_solve_new_soft_thread(hard_thread);
  40d941:	4c 89 f7             	mov    %r14,%rdi
    HT_FIELD(hard_thread, num_soft_threads) = 0;
  40d944:	49 c7 86 20 05 00 00 	movq   $0x0,0x520(%r14)
  40d94b:	00 00 00 00 
    HT_FIELD(hard_thread, soft_threads) = NULL;
  40d94f:	49 c7 86 c0 00 00 00 	movq   $0x0,0xc0(%r14)
  40d956:	00 00 00 00 
    fc_solve_new_soft_thread(hard_thread);
  40d95a:	e8 01 3d ff ff       	callq  401660 <fc_solve_new_soft_thread>
    fc_solve_compact_allocator_init(&(HT_FIELD(hard_thread, allocator)),
  40d95f:	49 8b 96 b0 05 00 00 	mov    0x5b0(%r14),%rdx
    HT_FIELD(hard_thread, ht__max_num_checked_states) = FCS_INT_LIMIT_MAX;
  40d966:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  40d96d:	ff ff 7f 
    allocator->old_list = NULL;
  40d970:	49 c7 86 d8 00 00 00 	movq   $0x0,0xd8(%r14)
  40d977:	00 00 00 00 
  40d97b:	49 89 86 c8 00 00 00 	mov    %rax,0xc8(%r14)
    HT_FIELD(hard_thread, prelude) = NULL;
  40d982:	49 c7 86 10 05 00 00 	movq   $0x0,0x510(%r14)
  40d989:	00 00 00 00 
    HT_FIELD(hard_thread, prelude_num_items) = 0;
  40d98d:	49 c7 86 00 05 00 00 	movq   $0x0,0x500(%r14)
  40d994:	00 00 00 00 
    char *const ret = meta_alloc->recycle_bin;
  40d998:	48 8b 02             	mov    (%rdx),%rax
    allocator->meta = meta_alloc;
  40d99b:	49 89 96 f8 00 00 00 	mov    %rdx,0xf8(%r14)
    HT_FIELD(hard_thread, num_soft_threads_finished) = 0;
  40d9a2:	41 c7 86 28 05 00 00 	movl   $0x0,0x528(%r14)
  40d9a9:	00 00 00 00 
    if (ret)
  40d9ad:	48 85 c0             	test   %rax,%rax
  40d9b0:	0f 84 2b 12 00 00    	je     40ebe1 <worker_thread+0x1311>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40d9b6:	48 8b 08             	mov    (%rax),%rcx
  40d9b9:	48 89 0a             	mov    %rcx,(%rdx)
        return ret;
  40d9bc:	49 8b 96 d8 00 00 00 	mov    0xd8(%r14),%rdx
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40d9c3:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d9c6:	48 8d 50 08          	lea    0x8(%rax),%rdx
#define freecell_solver_user_set_soft_thread_name(st, n)
static inline void my_init_instance(void *const instance)
{
    FCS__DECL_ERR_PTR(fcs_user_errstr);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "01j234" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40d9ca:	31 f6                	xor    %esi,%esi
  40d9cc:	4c 89 f7             	mov    %r14,%rdi
    allocator->old_list = new_data;
  40d9cf:	49 89 86 d8 00 00 00 	mov    %rax,0xd8(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40d9d6:	48 05 80 fe 00 00    	add    $0xfe80,%rax
  40d9dc:	49 89 86 e0 00 00 00 	mov    %rax,0xe0(%r14)
    user->soft_thread = &(INST_HT0(instance).soft_threads[0]);
  40d9e3:	49 8b 86 c0 00 00 00 	mov    0xc0(%r14),%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d9ea:	49 89 96 f0 00 00 00 	mov    %rdx,0xf0(%r14)
  40d9f1:	49 89 96 e8 00 00 00 	mov    %rdx,0xe8(%r14)
  40d9f8:	ba 34 f0 40 00       	mov    $0x40f034,%edx
    user->ret_code = flare->ret_code = FCS_STATE_NOT_BEGAN_YET;
  40d9fd:	41 c7 86 b8 05 00 00 	movl   $0x9,0x5b8(%r14)
  40da04:	09 00 00 00 
    user->soft_thread = &(INST_HT0(instance).soft_threads[0]);
  40da08:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
    user->ret_code = flare->ret_code = FCS_STATE_NOT_BEGAN_YET;
  40da0f:	41 c7 86 38 06 00 00 	movl   $0x9,0x638(%r14)
  40da16:	09 00 00 00 
    flare->instance_is_ready = TRUE;
  40da1a:	41 c6 86 bc 05 00 00 	movb   $0x1,0x5bc(%r14)
  40da21:	01 
    flare->obj_stats = initial_stats;
  40da22:	49 c7 86 c0 05 00 00 	movq   $0x0,0x5c0(%r14)
  40da29:	00 00 00 00 

    case FCS_METHOD_RANDOM_DFS:
    case FCS_METHOD_SOFT_DFS:
    {
        super_method_type = FCS_SUPER_METHOD_DFS;
        soft_thread->master_to_randomize =
  40da2d:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    }
    break;
#endif
    }

    soft_thread->super_method_type = super_method_type;
  40da34:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40da3b:	e8 40 c6 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,33, "016[234j]=asw(1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40da40:	4c 89 f7             	mov    %r14,%rdi
  40da43:	ba 3b f0 40 00       	mov    $0x40f03b,%edx
  40da48:	be 21 00 00 00       	mov    $0x21,%esi
  40da4d:	e8 2e c6 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40da52:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
#endif

int DLLEXPORT freecell_solver_user_next_soft_thread(void *const api_instance)
{
    fcs_user *const user = (fcs_user *const)api_instance;
    const_AUTO(
  40da59:	48 8b 38             	mov    (%rax),%rdi
{
    fcs_soft_thread *const soft_thread = api_soft_thread(api_instance);

    if (!strcmp(pruning, "r:tf"))
    {
        soft_thread->enable_pruning = TRUE;
  40da5c:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40da63:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40da6a:	f4 01 00 00 
    const_AUTO(
  40da6e:	e8 ed 3b ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40da73:	48 85 c0             	test   %rax,%rax
  40da76:	0f 84 d5 10 00 00    	je     40eb51 <worker_thread+0x1281>
    user->soft_thread = soft_thread;
  40da7c:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"24");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "0[124]=asw(1)j[36]=asw(1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40da83:	31 f6                	xor    %esi,%esi
  40da85:	ba 4c f0 40 00       	mov    $0x40f04c,%edx
  40da8a:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40da8d:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40da94:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40da9b:	e8 e0 c5 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,55, "016[234j]=asw(1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40daa0:	4c 89 f7             	mov    %r14,%rdi
  40daa3:	ba 3b f0 40 00       	mov    $0x40f03b,%edx
  40daa8:	be 37 00 00 00       	mov    $0x37,%esi
  40daad:	e8 ce c5 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40dab2:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40dab9:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40dabc:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40dac3:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40daca:	f4 01 00 00 
    const_AUTO(
  40dace:	e8 8d 3b ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dad3:	48 85 c0             	test   %rax,%rax
  40dad6:	0f 84 81 10 00 00    	je     40eb5d <worker_thread+0x128d>
    user->soft_thread = soft_thread;
  40dadc:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"5");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_random_seed(instance,6);
freecell_solver_user_set_depth_tests_order(instance,0, "0j26[34]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dae3:	31 f6                	xor    %esi,%esi
  40dae5:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40dae8:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
  40daef:	ba 66 f0 40 00       	mov    $0x40f066,%edx
    soft_thread->super_method_type = super_method_type;
  40daf4:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40dafb:	c7 40 48 06 00 00 00 	movl   $0x6,0x48(%rax)
  40db02:	e8 79 c5 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40db07:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40db0e:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40db11:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40db18:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40db1f:	f4 01 00 00 
    const_AUTO(
  40db23:	e8 38 3b ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40db28:	48 85 c0             	test   %rax,%rax
  40db2b:	0f 84 38 10 00 00    	je     40eb69 <worker_thread+0x1299>
    user->soft_thread = soft_thread;
  40db31:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"9");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "012j[35]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40db38:	31 f6                	xor    %esi,%esi
  40db3a:	ba 6f f0 40 00       	mov    $0x40f06f,%edx
  40db3f:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40db42:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40db49:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40db50:	e8 2b c5 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,9, "[012]j[468]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40db55:	ba 78 f0 40 00       	mov    $0x40f078,%edx
  40db5a:	be 09 00 00 00       	mov    $0x9,%esi
  40db5f:	4c 89 f7             	mov    %r14,%rdi
  40db62:	e8 19 c5 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,15, "[012346j8]=asw(1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40db67:	4c 89 f7             	mov    %r14,%rdi
  40db6a:	ba 84 f0 40 00       	mov    $0x40f084,%edx
  40db6f:	be 0f 00 00 00       	mov    $0xf,%esi
  40db74:	e8 07 c5 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40db79:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40db80:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40db83:	c7 40 48 e4 28 00 00 	movl   $0x28e4,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40db8a:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40db91:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40db95:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40db9c:	e8 bf 3a ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dba1:	48 85 c0             	test   %rax,%rax
  40dba4:	0f 84 d7 0f 00 00    	je     40eb81 <worker_thread+0x12b1>
    user->soft_thread = soft_thread;
  40dbaa:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"sI");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "01[2345j]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dbb1:	31 f6                	xor    %esi,%esi
  40dbb3:	ba 96 f0 40 00       	mov    $0x40f096,%edx
  40dbb8:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40dbbb:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40dbc2:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40dbc9:	e8 b2 c4 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,9, "012[456j]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dbce:	4c 89 f7             	mov    %r14,%rdi
  40dbd1:	ba a0 f0 40 00       	mov    $0x40f0a0,%edx
  40dbd6:	be 09 00 00 00       	mov    $0x9,%esi
  40dbdb:	e8 a0 c4 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40dbe0:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40dbe7:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40dbea:	c7 40 48 da ac 00 00 	movl   $0xacda,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40dbf1:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40dbf8:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40dbfc:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40dc03:	e8 58 3a ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dc08:	48 85 c0             	test   %rax,%rax
  40dc0b:	0f 84 7c 0f 00 00    	je     40eb8d <worker_thread+0x12bd>
    user->soft_thread = soft_thread;
  40dc11:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"sF");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "[01][2345j]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dc18:	31 f6                	xor    %esi,%esi
  40dc1a:	ba aa f0 40 00       	mov    $0x40f0aa,%edx
  40dc1f:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40dc22:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40dc29:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40dc30:	e8 4b c4 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,5, "[0123][456j]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dc35:	ba b6 f0 40 00       	mov    $0x40f0b6,%edx
  40dc3a:	be 05 00 00 00       	mov    $0x5,%esi
  40dc3f:	4c 89 f7             	mov    %r14,%rdi
  40dc42:	e8 39 c4 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,13, "[0123456j]=asw(1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dc47:	4c 89 f7             	mov    %r14,%rdi
  40dc4a:	ba c3 f0 40 00       	mov    $0x40f0c3,%edx
  40dc4f:	be 0d 00 00 00       	mov    $0xd,%esi
  40dc54:	e8 27 c4 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40dc59:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40dc60:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40dc63:	c7 40 48 78 47 00 00 	movl   $0x4778,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40dc6a:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40dc71:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40dc75:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40dc7c:	e8 df 39 ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dc81:	48 85 c0             	test   %rax,%rax
  40dc84:	0f 84 0f 0f 00 00    	je     40eb99 <worker_thread+0x12c9>
    user->soft_thread = soft_thread;
  40dc8a:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"sH");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "[01][2345j]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dc91:	31 f6                	xor    %esi,%esi
  40dc93:	ba aa f0 40 00       	mov    $0x40f0aa,%edx
  40dc98:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40dc9b:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40dca2:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40dca9:	e8 d2 c3 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,5, "[0123][456j]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dcae:	ba b6 f0 40 00       	mov    $0x40f0b6,%edx
  40dcb3:	be 05 00 00 00       	mov    $0x5,%esi
  40dcb8:	4c 89 f7             	mov    %r14,%rdi
  40dcbb:	e8 c0 c3 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,13, "[0123456j]=asw(1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dcc0:	4c 89 f7             	mov    %r14,%rdi
  40dcc3:	ba c3 f0 40 00       	mov    $0x40f0c3,%edx
  40dcc8:	be 0d 00 00 00       	mov    $0xd,%esi
  40dccd:	e8 ae c3 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40dcd2:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40dcd9:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40dcdc:	c7 40 48 5b 83 00 00 	movl   $0x835b,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40dce3:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40dcea:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40dcee:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40dcf5:	e8 66 39 ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dcfa:	48 85 c0             	test   %rax,%rax
  40dcfd:	0f 84 a2 0e 00 00    	je     40eba5 <worker_thread+0x12d5>
    user->soft_thread = soft_thread;
  40dd03:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"sG");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "0123456j" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dd0a:	31 f6                	xor    %esi,%esi
  40dd0c:	ba d5 f0 40 00       	mov    $0x40f0d5,%edx
  40dd11:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40dd14:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40dd1b:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40dd22:	e8 59 c3 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,13, "01[8j465]=asw(1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dd27:	ba de f0 40 00       	mov    $0x40f0de,%edx
  40dd2c:	be 0d 00 00 00       	mov    $0xd,%esi
  40dd31:	4c 89 f7             	mov    %r14,%rdi
  40dd34:	e8 47 c3 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,26, "26[013458j]=asw(1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dd39:	4c 89 f7             	mov    %r14,%rdi
  40dd3c:	ba ef f0 40 00       	mov    $0x40f0ef,%edx
  40dd41:	be 1a 00 00 00       	mov    $0x1a,%esi
  40dd46:	e8 35 c3 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40dd4b:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40dd52:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40dd55:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40dd5c:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40dd63:	f4 01 00 00 
    const_AUTO(
  40dd67:	e8 f4 38 ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dd6c:	48 85 c0             	test   %rax,%rax
  40dd6f:	0f 84 3c 0e 00 00    	je     40ebb1 <worker_thread+0x12e1>
    user->soft_thread = soft_thread;
  40dd75:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"32");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "[01]=asw(1)[23456j89]=asw(1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dd7c:	31 f6                	xor    %esi,%esi
  40dd7e:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40dd81:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
  40dd88:	ba 02 f1 40 00       	mov    $0x40f102,%edx
    soft_thread->super_method_type = super_method_type;
  40dd8d:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40dd94:	e8 e7 c2 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40dd99:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40dda0:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40dda3:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40ddaa:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40ddb1:	f4 01 00 00 
    const_AUTO(
  40ddb5:	e8 a6 38 ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40ddba:	48 85 c0             	test   %rax,%rax
  40ddbd:	0f 84 fa 0d 00 00    	je     40ebbd <worker_thread+0x12ed>
    user->soft_thread = soft_thread;
  40ddc3:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"12");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "0123" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40ddca:	31 f6                	xor    %esi,%esi
  40ddcc:	ba 1f f1 40 00       	mov    $0x40f11f,%edx
  40ddd1:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40ddd4:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40dddb:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40dde2:	e8 99 c2 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,6, "01[2435]=asw(3,20,10,0,1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dde7:	ba 24 f1 40 00       	mov    $0x40f124,%edx
  40ddec:	be 06 00 00 00       	mov    $0x6,%esi
  40ddf1:	4c 89 f7             	mov    %r14,%rdi
  40ddf4:	e8 87 c2 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,13, "[0123456j]=asw(1)" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40ddf9:	4c 89 f7             	mov    %r14,%rdi
  40ddfc:	ba c3 f0 40 00       	mov    $0x40f0c3,%edx
  40de01:	be 0d 00 00 00       	mov    $0xd,%esi
  40de06:	e8 75 c2 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40de0b:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40de12:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40de15:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40de1c:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40de23:	f4 01 00 00 
    const_AUTO(
  40de27:	e8 34 38 ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40de2c:	48 85 c0             	test   %rax,%rax
  40de2f:	0f 84 94 0d 00 00    	je     40ebc9 <worker_thread+0x12f9>
    user->soft_thread = soft_thread;
  40de35:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"new");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "[01][2345j]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40de3c:	31 f6                	xor    %esi,%esi
  40de3e:	ba aa f0 40 00       	mov    $0x40f0aa,%edx
  40de43:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40de46:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40de4d:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40de54:	e8 27 c2 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,7, "[0123][456j]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40de59:	4c 89 f7             	mov    %r14,%rdi
  40de5c:	ba b6 f0 40 00       	mov    $0x40f0b6,%edx
  40de61:	be 07 00 00 00       	mov    $0x7,%esi
  40de66:	e8 15 c2 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40de6b:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40de72:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40de75:	c7 40 48 39 80 01 00 	movl   $0x18039,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40de7c:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40de83:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40de87:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40de8e:	e8 cd 37 ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40de93:	48 85 c0             	test   %rax,%rax
  40de96:	0f 84 39 0d 00 00    	je     40ebd5 <worker_thread+0x1305>
    user->soft_thread = soft_thread;
  40de9c:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"sD");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "[01][23456j89]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40dea3:	31 f6                	xor    %esi,%esi
  40dea5:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40dea8:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
  40deaf:	ba 3e f1 40 00       	mov    $0x40f13e,%edx
    soft_thread->super_method_type = super_method_type;
  40deb4:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40debb:	e8 c0 c1 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40dec0:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    const_AUTO(
  40dec7:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40deca:	c7 40 48 08 00 00 00 	movl   $0x8,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40ded1:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40ded8:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40dedc:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40dee3:	e8 78 37 ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dee8:	48 85 c0             	test   %rax,%rax
  40deeb:	0f 84 84 0c 00 00    	je     40eb75 <worker_thread+0x12a5>
    user->soft_thread = soft_thread;
  40def1:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
    const_AUTO(
  40def8:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->is_befs = TRUE;
  40defb:	c6 80 f2 01 00 00 01 	movb   $0x1,0x1f2(%rax)
    BEFS_VAR(soft_thread, weighting).befs_weights.weights[my_index] = weight;
  40df02:	c5 fd 28 05 b6 36 00 	vmovapd 0x36b6(%rip),%ymm0        # 4115c0 <fc_solve_is_parent_buf+0x1000>
  40df09:	00 
    soft_thread->super_method_type = super_method_type;
  40df0a:	c7 40 20 01 00 00 00 	movl   $0x1,0x20(%rax)
    BEFS_VAR(soft_thread, weighting).befs_weights.weights[my_index] = weight;
  40df11:	48 c7 80 c8 01 00 00 	movq   $0x0,0x1c8(%rax)
  40df18:	00 00 00 00 
  40df1c:	c5 f8 11 80 a8 01 00 	vmovups %xmm0,0x1a8(%rax)
  40df23:	00 
  40df24:	c4 e3 7d 19 80 b8 01 	vextractf128 $0x1,%ymm0,0x1b8(%rax)
  40df2b:	00 00 01 
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40df2e:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40df35:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40df39:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40df40:	c5 f8 77             	vzeroupper 
  40df43:	e8 18 37 ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40df48:	48 85 c0             	test   %rax,%rax
  40df4b:	0f 84 e8 0b 00 00    	je     40eb39 <worker_thread+0x1269>
    user->soft_thread = soft_thread;
  40df51:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"11");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_A_STAR);
freecell_solver_user_set_depth_tests_order(instance,0, "012346j" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40df58:	4c 89 f7             	mov    %r14,%rdi
  40df5b:	ba 4d f1 40 00       	mov    $0x40f14d,%edx
  40df60:	31 f6                	xor    %esi,%esi
        soft_thread->is_befs = TRUE;
  40df62:	c6 80 f2 01 00 00 01 	movb   $0x1,0x1f2(%rax)
    soft_thread->super_method_type = super_method_type;
  40df69:	c7 40 20 01 00 00 00 	movl   $0x1,0x20(%rax)
  40df70:	e8 0b c1 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40df75:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
    BEFS_VAR(soft_thread, weighting).befs_weights.weights[my_index] = weight;
  40df7c:	c5 fd 28 05 5c 36 00 	vmovapd 0x365c(%rip),%ymm0        # 4115e0 <fc_solve_is_parent_buf+0x1020>
  40df83:	00 
    const_AUTO(
  40df84:	48 8b 38             	mov    (%rax),%rdi
    BEFS_VAR(soft_thread, weighting).befs_weights.weights[my_index] = weight;
  40df87:	c5 f8 11 80 a8 01 00 	vmovups %xmm0,0x1a8(%rax)
  40df8e:	00 
  40df8f:	c4 e3 7d 19 80 b8 01 	vextractf128 $0x1,%ymm0,0x1b8(%rax)
  40df96:	00 00 01 
  40df99:	48 c7 80 c8 01 00 00 	movq   $0x0,0x1c8(%rax)
  40dfa0:	00 00 00 00 
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40dfa4:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40dfab:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40dfaf:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40dfb6:	c5 f8 77             	vzeroupper 
  40dfb9:	e8 a2 36 ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dfbe:	48 85 c0             	test   %rax,%rax
  40dfc1:	0f 84 7e 0b 00 00    	je     40eb45 <worker_thread+0x1275>
    user->soft_thread = soft_thread;
  40dfc7:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
    const_AUTO(
  40dfce:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40dfd1:	b9 01 01 00 00       	mov    $0x101,%ecx
    soft_thread->super_method_type = super_method_type;
  40dfd6:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40dfdd:	c7 40 48 69 00 00 00 	movl   $0x69,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40dfe4:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40dfeb:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40dfef:	66 89 88 f0 01 00 00 	mov    %cx,0x1f0(%rax)
    const_AUTO(
  40dff6:	e8 65 36 ff ff       	callq  401660 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dffb:	48 85 c0             	test   %rax,%rax
  40dffe:	0f 84 29 0b 00 00    	je     40eb2d <worker_thread+0x125d>
    user->soft_thread = soft_thread;
  40e004:	49 89 86 40 06 00 00 	mov    %rax,0x640(%r14)
freecell_solver_user_set_soft_thread_step(instance,500);
freecell_solver_user_set_pruning(instance,"r:tf" FCS__PASS_ERR_STR(&fcs_user_errstr));
freecell_solver_user_set_soft_thread_name(instance,"20");
freecell_solver_user_next_soft_thread(instance);
freecell_solver_user_set_solving_method(instance,FCS_METHOD_RANDOM_DFS);
freecell_solver_user_set_depth_tests_order(instance,0, "[01][2345j]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40e00b:	31 f6                	xor    %esi,%esi
  40e00d:	4c 89 f7             	mov    %r14,%rdi
        soft_thread->master_to_randomize =
  40e010:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    typeof(total_num_iters) total_num_iters_temp = 0;
  40e017:	45 31 ff             	xor    %r15d,%r15d
  40e01a:	ba aa f0 40 00       	mov    $0x40f0aa,%edx
    soft_thread->super_method_type = super_method_type;
  40e01f:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
    HT_FIELD(hard_thread, ht__max_num_checked_states) = FCS_INT_LIMIT_MAX;
  40e026:	4d 89 f5             	mov    %r14,%r13
  40e029:	e8 52 c0 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
freecell_solver_user_set_depth_tests_order(instance,8, "[0123][456j]" FCS__PASS_ERR_STR(&fcs_user_errstr));
  40e02e:	ba b6 f0 40 00       	mov    $0x40f0b6,%edx
  40e033:	be 08 00 00 00       	mov    $0x8,%esi
  40e038:	4c 89 f7             	mov    %r14,%rdi
  40e03b:	e8 40 c0 ff ff       	callq  40a080 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40e040:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40e047:	4c 8d 64 24 30       	lea    0x30(%rsp),%r12
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40e04c:	c7 40 48 25 97 00 00 	movl   $0x9725,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40e053:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40e05a:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40e05e:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    fcs_hard_thread *const hard_thread = user->soft_thread->hard_thread;
  40e065:	48 8b 00             	mov    (%rax),%rax
    HT_FIELD(hard_thread, prelude_num_items) = num;
  40e068:	48 c7 80 00 05 00 00 	movq   $0x14,0x500(%rax)
  40e06f:	14 00 00 00 
    HT_FIELD(hard_thread, prelude) = prelude;
  40e073:	48 c7 80 10 05 00 00 	movq   $0x40f9e0,0x510(%rax)
  40e07a:	e0 f9 40 00 
        pthread_mutex_lock(&next_board_num_lock);
  40e07e:	bf 60 41 41 00       	mov    $0x414160,%edi
  40e083:	e8 c8 30 ff ff       	callq  401150 <pthread_mutex_lock@plt>
        board_num = next_board_num;
  40e088:	48 8b 1d c1 60 00 00 	mov    0x60c1(%rip),%rbx        # 414150 <next_board_num>
        pthread_mutex_unlock(&next_board_num_lock);
  40e08f:	bf 60 41 41 00       	mov    $0x414160,%edi
        const long long proposed_quota_end = (next_board_num += board_num_step);
  40e094:	4c 8b 35 35 60 00 00 	mov    0x6035(%rip),%r14        # 4140d0 <board_num_step>
  40e09b:	49 01 de             	add    %rbx,%r14
  40e09e:	4c 89 35 ab 60 00 00 	mov    %r14,0x60ab(%rip)        # 414150 <next_board_num>
        pthread_mutex_unlock(&next_board_num_lock);
  40e0a5:	e8 16 30 ff ff       	callq  4010c0 <pthread_mutex_unlock@plt>
        const long long quota_end = min(proposed_quota_end, past_end_board);
  40e0aa:	48 8b 05 97 60 00 00 	mov    0x6097(%rip),%rax        # 414148 <past_end_board>
  40e0b1:	49 39 c6             	cmp    %rax,%r14
  40e0b4:	4c 0f 4f f0          	cmovg  %rax,%r14
  40e0b8:	4c 89 74 24 28       	mov    %r14,0x28(%rsp)
        for (; board_num < quota_end; board_num++)
  40e0bd:	4c 39 f3             	cmp    %r14,%rbx
  40e0c0:	0f 8d 37 0b 00 00    	jge    40ebfd <worker_thread+0x132d>
  40e0c6:	49 8d 85 48 0a 00 00 	lea    0xa48(%r13),%rax
  40e0cd:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
    FCS_GET_TIME(ret);
  40e0d2:	48 8d 84 24 f0 00 00 	lea    0xf0(%rsp),%rax
  40e0d9:	00 
  40e0da:	48 89 44 24 20       	mov    %rax,0x20(%rsp)
  40e0df:	90                   	nop
#else
static inline void get_board_l(const long long deal_idx, char *const ret)
#endif
{
    long long seedx = microsoft_rand__calc_init_seedx(deal_idx);
    strcpy(ret, "XX XX XX XX XX XX XX\n"
  40e0e0:	c5 f9 6f 05 58 34 00 	vmovdqa 0x3458(%rip),%xmm0        # 411540 <fc_solve_is_parent_buf+0xf80>
  40e0e7:	00 
  40e0e8:	89 d9                	mov    %ebx,%ecx
    {
        deck[i] = i;
    }

    microsoft_rand_uint num_cards_left = 52;
    for (size_t i = 0; i < 52; ++i)
  40e0ea:	31 ff                	xor    %edi,%edi
    strcpy(ret, "XX XX XX XX XX XX XX\n"
  40e0ec:	48 b8 20 58 58 20 58 	movabs $0x5820585820585820,%rax
  40e0f3:	58 20 58 
        deck[i] = i;
  40e0f6:	c5 fd 6f 0d 02 35 00 	vmovdqa 0x3502(%rip),%ymm1        # 411600 <fc_solve_is_parent_buf+0x1040>
  40e0fd:	00 
    strcpy(ret, "XX XX XX XX XX XX XX\n"
  40e0fe:	49 89 44 24 20       	mov    %rax,0x20(%r12)
  40e103:	48 ba 58 0a 58 58 20 	movabs $0x2058582058580a58,%rdx
  40e10a:	58 58 20 
    microsoft_rand_uint num_cards_left = 52;
  40e10d:	be 34 00 00 00       	mov    $0x34,%esi
    strcpy(ret, "XX XX XX XX XX XX XX\n"
  40e112:	c4 c1 78 29 04 24    	vmovaps %xmm0,(%r12)
  40e118:	c5 f9 6f 05 30 34 00 	vmovdqa 0x3430(%rip),%xmm0        # 411550 <fc_solve_is_parent_buf+0xf90>
  40e11f:	00 
        deck[i] = i;
  40e120:	c5 fd 6f 15 f8 34 00 	vmovdqa 0x34f8(%rip),%ymm2        # 411620 <fc_solve_is_parent_buf+0x1060>
  40e127:	00 
    strcpy(ret, "XX XX XX XX XX XX XX\n"
  40e128:	49 89 84 24 80 00 00 	mov    %rax,0x80(%r12)
  40e12f:	00 
  40e130:	48 b8 58 58 20 58 58 	movabs $0x5858205858205858,%rax
  40e137:	20 58 58 
  40e13a:	c4 c1 78 29 44 24 10 	vmovaps %xmm0,0x10(%r12)
  40e141:	c5 f9 6f 05 17 34 00 	vmovdqa 0x3417(%rip),%xmm0        # 411560 <fc_solve_is_parent_buf+0xfa0>
  40e148:	00 
        deck[i] = i;
  40e149:	c5 fd 6f 1d ef 34 00 	vmovdqa 0x34ef(%rip),%ymm3        # 411640 <fc_solve_is_parent_buf+0x1080>
  40e150:	00 
    strcpy(ret, "XX XX XX XX XX XX XX\n"
  40e151:	49 89 84 24 90 00 00 	mov    %rax,0x90(%r12)
  40e158:	00 
  40e159:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
  40e15e:	c4 c1 78 29 44 24 30 	vmovaps %xmm0,0x30(%r12)
  40e165:	c5 f9 6f 05 03 34 00 	vmovdqa 0x3403(%rip),%xmm0        # 411570 <fc_solve_is_parent_buf+0xfb0>
  40e16c:	00 
        deck[i] = i;
  40e16d:	c5 fd 6f 25 eb 34 00 	vmovdqa 0x34eb(%rip),%ymm4        # 411660 <fc_solve_is_parent_buf+0x10a0>
  40e174:	00 
    strcpy(ret, "XX XX XX XX XX XX XX\n"
  40e175:	49 89 54 24 28       	mov    %rdx,0x28(%r12)
  40e17a:	c4 c1 78 29 44 24 40 	vmovaps %xmm0,0x40(%r12)
  40e181:	c5 f9 6f 05 f7 33 00 	vmovdqa 0x33f7(%rip),%xmm0        # 411580 <fc_solve_is_parent_buf+0xfc0>
  40e188:	00 
        deck[i] = i;
  40e189:	c5 fd 6f 2d ef 34 00 	vmovdqa 0x34ef(%rip),%ymm5        # 411680 <fc_solve_is_parent_buf+0x10c0>
  40e190:	00 
  40e191:	c5 fd 7f 8c 24 e0 00 	vmovdqa %ymm1,0xe0(%rsp)
  40e198:	00 00 
    strcpy(ret, "XX XX XX XX XX XX XX\n"
  40e19a:	c4 c1 78 29 44 24 50 	vmovaps %xmm0,0x50(%r12)
  40e1a1:	c5 f9 6f 05 e7 33 00 	vmovdqa 0x33e7(%rip),%xmm0        # 411590 <fc_solve_is_parent_buf+0xfd0>
  40e1a8:	00 
        deck[i] = i;
  40e1a9:	c5 fd 6f 35 ef 34 00 	vmovdqa 0x34ef(%rip),%ymm6        # 4116a0 <fc_solve_is_parent_buf+0x10e0>
  40e1b0:	00 
  40e1b1:	c5 fd 7f 94 24 00 01 	vmovdqa %ymm2,0x100(%rsp)
  40e1b8:	00 00 
    strcpy(ret, "XX XX XX XX XX XX XX\n"
  40e1ba:	c4 c1 78 29 44 24 60 	vmovaps %xmm0,0x60(%r12)
  40e1c1:	c5 f9 6f 05 d7 33 00 	vmovdqa 0x33d7(%rip),%xmm0        # 4115a0 <fc_solve_is_parent_buf+0xfe0>
  40e1c8:	00 
        deck[i] = i;
  40e1c9:	c5 fd 7f 9c 24 20 01 	vmovdqa %ymm3,0x120(%rsp)
  40e1d0:	00 00 
  40e1d2:	c5 fd 7f a4 24 40 01 	vmovdqa %ymm4,0x140(%rsp)
  40e1d9:	00 00 
  40e1db:	c5 fd 7f ac 24 60 01 	vmovdqa %ymm5,0x160(%rsp)
  40e1e2:	00 00 
    strcpy(ret, "XX XX XX XX XX XX XX\n"
  40e1e4:	c4 c1 78 29 44 24 70 	vmovaps %xmm0,0x70(%r12)
  40e1eb:	49 89 94 24 88 00 00 	mov    %rdx,0x88(%r12)
  40e1f2:	00 
  40e1f3:	41 c7 84 24 98 00 00 	movl   $0xa585820,0x98(%r12)
  40e1fa:	00 20 58 58 0a 
  40e1ff:	41 c6 84 24 9c 00 00 	movb   $0x0,0x9c(%r12)
  40e206:	00 00 
        deck[i] = i;
  40e208:	c5 fd 7f b4 24 80 01 	vmovdqa %ymm6,0x180(%rsp)
  40e20f:	00 00 
  40e211:	c5 fd 6f 3d a7 34 00 	vmovdqa 0x34a7(%rip),%ymm7        # 4116c0 <fc_solve_is_parent_buf+0x1100>
  40e218:	00 
  40e219:	c5 fd 6f 0d bf 34 00 	vmovdqa 0x34bf(%rip),%ymm1        # 4116e0 <fc_solve_is_parent_buf+0x1120>
  40e220:	00 
  40e221:	c5 fd 6f 15 d7 34 00 	vmovdqa 0x34d7(%rip),%ymm2        # 411700 <fc_solve_is_parent_buf+0x1140>
  40e228:	00 
  40e229:	c5 fd 7f bc 24 a0 01 	vmovdqa %ymm7,0x1a0(%rsp)
  40e230:	00 00 
  40e232:	c5 fd 6f 1d e6 34 00 	vmovdqa 0x34e6(%rip),%ymm3        # 411720 <fc_solve_is_parent_buf+0x1160>
  40e239:	00 
  40e23a:	c5 fd 7f 8c 24 c0 01 	vmovdqa %ymm1,0x1c0(%rsp)
  40e241:	00 00 
  40e243:	c5 fd 6f 25 f5 34 00 	vmovdqa 0x34f5(%rip),%ymm4        # 411740 <fc_solve_is_parent_buf+0x1180>
  40e24a:	00 
  40e24b:	c5 fd 7f 94 24 e0 01 	vmovdqa %ymm2,0x1e0(%rsp)
  40e252:	00 00 
  40e254:	c5 fd 6f 2d 04 35 00 	vmovdqa 0x3504(%rip),%ymm5        # 411760 <fc_solve_is_parent_buf+0x11a0>
  40e25b:	00 
  40e25c:	c5 fd 7f 9c 24 00 02 	vmovdqa %ymm3,0x200(%rsp)
  40e263:	00 00 
  40e265:	c5 fd 6f 35 13 35 00 	vmovdqa 0x3513(%rip),%ymm6        # 411780 <fc_solve_is_parent_buf+0x11c0>
  40e26c:	00 
  40e26d:	c5 fd 7f a4 24 20 02 	vmovdqa %ymm4,0x220(%rsp)
  40e274:	00 00 
  40e276:	c5 fd 7f ac 24 40 02 	vmovdqa %ymm5,0x240(%rsp)
  40e27d:	00 00 
  40e27f:	c5 fd 7f b4 24 60 02 	vmovdqa %ymm6,0x260(%rsp)
  40e286:	00 00 
  40e288:	48 39 c3             	cmp    %rax,%rbx
  40e28b:	0f 8f df 01 00 00    	jg     40e470 <worker_thread+0xba0>
  40e291:	48 81 fb ff ff ff 7f 	cmp    $0x7fffffff,%rbx
  40e298:	0f 8f 52 02 00 00    	jg     40e4f0 <worker_thread+0xc20>
  40e29e:	66 90                	xchg   %ax,%ax
}

static inline microsoft_rand_uint microsoft_rand__game_num_rand(
    microsoft_rand *const seedx_ptr, const long long gnGameNumber)
{
    if (gnGameNumber < 0x100000000LL)
  40e2a0:	48 69 c9 fd 43 03 00 	imul   $0x343fd,%rcx,%rcx
    {
        const microsoft_rand_uint j =
  40e2a7:	31 d2                	xor    %edx,%edx
            microsoft_rand__game_num_rand(&seedx, deal_idx) % num_cards_left;
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e2a9:	4c 8b 04 fd 20 fb 40 	mov    0x40fb20(,%rdi,8),%r8
  40e2b0:	00 
    for (size_t i = 0; i < 52; ++i)
  40e2b1:	48 83 c7 01          	add    $0x1,%rdi
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e2b5:	4d 01 e0             	add    %r12,%r8
  40e2b8:	48 81 c1 c3 9e 26 00 	add    $0x269ec3,%rcx
    return ((*my_rand) >> 16) & 0x7fff;
  40e2bf:	48 89 c8             	mov    %rcx,%rax
  40e2c2:	48 c1 f8 10          	sar    $0x10,%rax
  40e2c6:	25 ff 7f 00 00       	and    $0x7fff,%eax
        const microsoft_rand_uint j =
  40e2cb:	f7 f6                	div    %esi
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e2cd:	89 d2                	mov    %edx,%edx
  40e2cf:	48 8b 84 d4 e0 00 00 	mov    0xe0(%rsp,%rdx,8),%rax
  40e2d6:	00 
    s[0] = card_to_string_values[VALUE(card)];
  40e2d7:	49 89 c1             	mov    %rax,%r9
    s[1] = card_to_string_suits[SUIT(card)];
  40e2da:	83 e0 03             	and    $0x3,%eax
  40e2dd:	0f b6 80 63 f1 40 00 	movzbl 0x40f163(%rax),%eax
    s[0] = card_to_string_values[VALUE(card)];
  40e2e4:	49 c1 e9 02          	shr    $0x2,%r9
  40e2e8:	45 0f b6 89 55 f1 40 	movzbl 0x40f155(%r9),%r9d
  40e2ef:	00 
    s[1] = card_to_string_suits[SUIT(card)];
  40e2f0:	41 88 40 01          	mov    %al,0x1(%r8)
        deck[j] = deck[--num_cards_left];
  40e2f4:	8d 46 ff             	lea    -0x1(%rsi),%eax
  40e2f7:	48 89 c6             	mov    %rax,%rsi
  40e2fa:	48 8b 84 c4 e0 00 00 	mov    0xe0(%rsp,%rax,8),%rax
  40e301:	00 
    s[0] = card_to_string_values[VALUE(card)];
  40e302:	45 88 08             	mov    %r9b,(%r8)
        deck[j] = deck[--num_cards_left];
  40e305:	48 89 84 d4 e0 00 00 	mov    %rax,0xe0(%rsp,%rdx,8)
  40e30c:	00 
    for (size_t i = 0; i < 52; ++i)
  40e30d:	48 83 ff 34          	cmp    $0x34,%rdi
  40e311:	75 8d                	jne    40e2a0 <worker_thread+0x9d0>
    const size_t len = strlen(orig_str);
  40e313:	4d 89 e6             	mov    %r12,%r14
  40e316:	41 8b 16             	mov    (%r14),%edx
  40e319:	49 83 c6 04          	add    $0x4,%r14
  40e31d:	8d 82 ff fe fe fe    	lea    -0x1010101(%rdx),%eax
  40e323:	f7 d2                	not    %edx
  40e325:	21 d0                	and    %edx,%eax
  40e327:	25 80 80 80 80       	and    $0x80808080,%eax
  40e32c:	74 e8                	je     40e316 <worker_thread+0xa46>
  40e32e:	89 c2                	mov    %eax,%edx
  40e330:	c1 ea 10             	shr    $0x10,%edx
  40e333:	a9 80 80 00 00       	test   $0x8080,%eax
  40e338:	0f 44 c2             	cmove  %edx,%eax
  40e33b:	49 8d 56 02          	lea    0x2(%r14),%rdx
  40e33f:	89 c6                	mov    %eax,%esi
  40e341:	4c 0f 44 f2          	cmove  %rdx,%r14
  40e345:	40 00 c6             	add    %al,%sil
  40e348:	49 83 de 03          	sbb    $0x3,%r14
    if (len)
  40e34c:	4d 29 e6             	sub    %r12,%r14
  40e34f:	0f 84 1b 02 00 00    	je     40e570 <worker_thread+0xca0>
        strcpy(s, orig_str);
  40e355:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  40e35a:	49 8d 56 01          	lea    0x1(%r14),%rdx
  40e35e:	4c 89 e6             	mov    %r12,%rsi
  40e361:	c5 f8 77             	vzeroupper 
  40e364:	e8 77 2d ff ff       	callq  4010e0 <memcpy@plt>
        char *s_end = s + len - 1;
  40e369:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  40e36e:	4a 8d 44 30 ff       	lea    -0x1(%rax,%r14,1),%rax
        if ((*s_end) != TRAILING_CHAR)
  40e373:	80 38 0a             	cmpb   $0xa,(%rax)
  40e376:	74 09                	je     40e381 <worker_thread+0xab1>
            *(++s_end) = TRAILING_CHAR;
  40e378:	ba 0a 00 00 00       	mov    $0xa,%edx
  40e37d:	66 89 50 01          	mov    %dx,0x1(%rax)
    return resume_solution(user);
  40e381:	4c 89 ef             	mov    %r13,%rdi
  40e384:	e8 67 bf ff ff       	callq  40a2f0 <resume_solution>
  40e389:	83 f8 05             	cmp    $0x5,%eax
  40e38c:	0f 84 ff 01 00 00    	je     40e591 <worker_thread+0xcc1>
  40e392:	83 f8 0c             	cmp    $0xc,%eax
  40e395:	0f 84 a5 02 00 00    	je     40e640 <worker_thread+0xd70>
  40e39b:	83 f8 01             	cmp    $0x1,%eax
  40e39e:	0f 84 5c 02 00 00    	je     40e600 <worker_thread+0xd30>
    return user->iterations_board_started_at.num_checked_states +
  40e3a4:	49 8b 45 00          	mov    0x0(%r13),%rax
  40e3a8:	49 39 85 c0 05 00 00 	cmp    %rax,0x5c0(%r13)
  40e3af:	49 0f 4d 85 c0 05 00 	cmovge 0x5c0(%r13),%rax
  40e3b6:	00 
  40e3b7:	49 03 85 c8 05 00 00 	add    0x5c8(%r13),%rax
               user_obj(user)->i__num_checked_states) -
  40e3be:	49 2b 85 d0 05 00 00 	sub    0x5d0(%r13),%rax
    *total_num_iters_temp += freecell_solver_user_get_num_times_long(instance);
  40e3c5:	49 01 c7             	add    %rax,%r15
            if (total_num_iters_temp >= UPDATE_TOTAL_NUM_ITERS_THRESHOLD)
  40e3c8:	49 81 ff 3f 42 0f 00 	cmp    $0xf423f,%r15
  40e3cf:	0f 8f fb 01 00 00    	jg     40e5d0 <worker_thread+0xd00>
            if (unlikely(board_num % stop_at == 0))
  40e3d5:	48 89 d8             	mov    %rbx,%rax
  40e3d8:	48 99                	cqto   
  40e3da:	48 f7 3d 1f 5d 00 00 	idivq  0x5d1f(%rip)        # 414100 <stop_at>
  40e3e1:	48 85 d2             	test   %rdx,%rdx
  40e3e4:	0f 84 a6 06 00 00    	je     40ea90 <worker_thread+0x11c0>
    if (flare->ret_code != FCS_STATE_NOT_BEGAN_YET)
  40e3ea:	41 83 bd b8 05 00 00 	cmpl   $0x9,0x5b8(%r13)
  40e3f1:	09 
  40e3f2:	74 24                	je     40e418 <worker_thread+0xb48>
    if (!flare->instance_is_ready)
  40e3f4:	41 80 bd bc 05 00 00 	cmpb   $0x0,0x5bc(%r13)
  40e3fb:	00 
  40e3fc:	0f 84 5e 05 00 00    	je     40e960 <worker_thread+0x1090>
        user->init_num_checked_states = initial_stats;
  40e402:	49 c7 85 d0 05 00 00 	movq   $0x0,0x5d0(%r13)
  40e409:	00 00 00 00 
        flare->ret_code = FCS_STATE_NOT_BEGAN_YET;
  40e40d:	41 c7 85 b8 05 00 00 	movl   $0x9,0x5b8(%r13)
  40e414:	09 00 00 00 
    flare->obj_stats = initial_stats;
  40e418:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
        for (; board_num < quota_end; board_num++)
  40e41c:	48 83 c3 01          	add    $0x1,%rbx
  40e420:	c4 c1 78 11 85 c0 05 	vmovups %xmm0,0x5c0(%r13)
  40e427:	00 00 
  40e429:	48 39 5c 24 28       	cmp    %rbx,0x28(%rsp)
  40e42e:	0f 85 ac fc ff ff    	jne    40e0e0 <worker_thread+0x810>
  40e434:	48 8b 05 0d 5d 00 00 	mov    0x5d0d(%rip),%rax        # 414148 <past_end_board>
    } while (board_num < past_end_board);
  40e43b:	48 39 44 24 28       	cmp    %rax,0x28(%rsp)
  40e440:	0f 8c 38 fc ff ff    	jl     40e07e <worker_thread+0x7ae>
    pthread_mutex_lock(&total_num_iters_lock);
  40e446:	bf 20 41 41 00       	mov    $0x414120,%edi
  40e44b:	4d 89 ee             	mov    %r13,%r14
  40e44e:	e8 fd 2c ff ff       	callq  401150 <pthread_mutex_lock@plt>
    pthread_mutex_unlock(&total_num_iters_lock);
  40e453:	bf 20 41 41 00       	mov    $0x414120,%edi
    total_num_iters += total_num_iters_temp;
  40e458:	4c 01 3d a9 5c 00 00 	add    %r15,0x5ca9(%rip)        # 414108 <total_num_iters>
    pthread_mutex_unlock(&total_num_iters_lock);
  40e45f:	e8 5c 2c ff ff       	callq  4010c0 <pthread_mutex_unlock@plt>
  40e464:	e9 f2 01 00 00       	jmpq   40e65b <worker_thread+0xd8b>
  40e469:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    if (gnGameNumber < 0x100000000LL)
  40e470:	48 69 c9 fd 43 03 00 	imul   $0x343fd,%rcx,%rcx
        const microsoft_rand_uint j =
  40e477:	31 d2                	xor    %edx,%edx
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e479:	4c 8b 04 fd 20 fb 40 	mov    0x40fb20(,%rdi,8),%r8
  40e480:	00 
    for (size_t i = 0; i < 52; ++i)
  40e481:	48 83 c7 01          	add    $0x1,%rdi
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e485:	4d 01 e0             	add    %r12,%r8
  40e488:	48 81 c1 c3 9e 26 00 	add    $0x269ec3,%rcx
    return ((*my_rand) >> 16) & 0xffff;
  40e48f:	89 c8                	mov    %ecx,%eax
  40e491:	c1 e8 10             	shr    $0x10,%eax
        const microsoft_rand_uint ret = microsoft_rand_rand(seedx_ptr);
        return ((gnGameNumber < 0x80000000) ? ret : (ret | 0x8000));
    }
    else
    {
        return microsoft_rand_randp(seedx_ptr) + 1;
  40e494:	83 c0 01             	add    $0x1,%eax
        const microsoft_rand_uint j =
  40e497:	f7 f6                	div    %esi
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e499:	89 d2                	mov    %edx,%edx
  40e49b:	48 8b 84 d4 e0 00 00 	mov    0xe0(%rsp,%rdx,8),%rax
  40e4a2:	00 
    s[0] = card_to_string_values[VALUE(card)];
  40e4a3:	49 89 c1             	mov    %rax,%r9
    s[1] = card_to_string_suits[SUIT(card)];
  40e4a6:	83 e0 03             	and    $0x3,%eax
  40e4a9:	0f b6 80 63 f1 40 00 	movzbl 0x40f163(%rax),%eax
    s[0] = card_to_string_values[VALUE(card)];
  40e4b0:	49 c1 e9 02          	shr    $0x2,%r9
  40e4b4:	45 0f b6 89 55 f1 40 	movzbl 0x40f155(%r9),%r9d
  40e4bb:	00 
    s[1] = card_to_string_suits[SUIT(card)];
  40e4bc:	41 88 40 01          	mov    %al,0x1(%r8)
        deck[j] = deck[--num_cards_left];
  40e4c0:	8d 46 ff             	lea    -0x1(%rsi),%eax
  40e4c3:	48 89 c6             	mov    %rax,%rsi
  40e4c6:	48 8b 84 c4 e0 00 00 	mov    0xe0(%rsp,%rax,8),%rax
  40e4cd:	00 
    s[0] = card_to_string_values[VALUE(card)];
  40e4ce:	45 88 08             	mov    %r9b,(%r8)
        deck[j] = deck[--num_cards_left];
  40e4d1:	48 89 84 d4 e0 00 00 	mov    %rax,0xe0(%rsp,%rdx,8)
  40e4d8:	00 
    for (size_t i = 0; i < 52; ++i)
  40e4d9:	48 83 ff 34          	cmp    $0x34,%rdi
  40e4dd:	75 91                	jne    40e470 <worker_thread+0xba0>
  40e4df:	e9 2f fe ff ff       	jmpq   40e313 <worker_thread+0xa43>
  40e4e4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e4eb:	00 00 00 00 
  40e4ef:	90                   	nop
    if (gnGameNumber < 0x100000000LL)
  40e4f0:	48 69 c9 fd 43 03 00 	imul   $0x343fd,%rcx,%rcx
        const microsoft_rand_uint j =
  40e4f7:	31 d2                	xor    %edx,%edx
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e4f9:	4c 8b 04 fd 20 fb 40 	mov    0x40fb20(,%rdi,8),%r8
  40e500:	00 
    for (size_t i = 0; i < 52; ++i)
  40e501:	48 83 c7 01          	add    $0x1,%rdi
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e505:	4d 01 e0             	add    %r12,%r8
  40e508:	48 81 c1 c3 9e 26 00 	add    $0x269ec3,%rcx
    return ((*my_rand) >> 16) & 0x7fff;
  40e50f:	48 89 c8             	mov    %rcx,%rax
  40e512:	48 c1 f8 10          	sar    $0x10,%rax
  40e516:	25 ff 7f 00 00       	and    $0x7fff,%eax
        return ((gnGameNumber < 0x80000000) ? ret : (ret | 0x8000));
  40e51b:	80 cc 80             	or     $0x80,%ah
        const microsoft_rand_uint j =
  40e51e:	f7 f6                	div    %esi
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e520:	89 d2                	mov    %edx,%edx
  40e522:	48 8b 84 d4 e0 00 00 	mov    0xe0(%rsp,%rdx,8),%rax
  40e529:	00 
    s[0] = card_to_string_values[VALUE(card)];
  40e52a:	49 89 c1             	mov    %rax,%r9
    s[1] = card_to_string_suits[SUIT(card)];
  40e52d:	83 e0 03             	and    $0x3,%eax
  40e530:	0f b6 80 63 f1 40 00 	movzbl 0x40f163(%rax),%eax
    s[0] = card_to_string_values[VALUE(card)];
  40e537:	49 c1 e9 02          	shr    $0x2,%r9
  40e53b:	45 0f b6 89 55 f1 40 	movzbl 0x40f155(%r9),%r9d
  40e542:	00 
    s[1] = card_to_string_suits[SUIT(card)];
  40e543:	41 88 40 01          	mov    %al,0x1(%r8)
        deck[j] = deck[--num_cards_left];
  40e547:	8d 46 ff             	lea    -0x1(%rsi),%eax
  40e54a:	48 89 c6             	mov    %rax,%rsi
  40e54d:	48 8b 84 c4 e0 00 00 	mov    0xe0(%rsp,%rax,8),%rax
  40e554:	00 
    s[0] = card_to_string_values[VALUE(card)];
  40e555:	45 88 08             	mov    %r9b,(%r8)
        deck[j] = deck[--num_cards_left];
  40e558:	48 89 84 d4 e0 00 00 	mov    %rax,0xe0(%rsp,%rdx,8)
  40e55f:	00 
    for (size_t i = 0; i < 52; ++i)
  40e560:	48 83 ff 34          	cmp    $0x34,%rdi
  40e564:	75 8a                	jne    40e4f0 <worker_thread+0xc20>
  40e566:	e9 a8 fd ff ff       	jmpq   40e313 <worker_thread+0xa43>
  40e56b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        s[0] = '\n';
  40e570:	b8 0a 00 00 00       	mov    $0xa,%eax
  40e575:	66 41 89 85 48 0a 00 	mov    %ax,0xa48(%r13)
  40e57c:	00 
  40e57d:	c5 f8 77             	vzeroupper 
    return resume_solution(user);
  40e580:	4c 89 ef             	mov    %r13,%rdi
  40e583:	e8 68 bd ff ff       	callq  40a2f0 <resume_solution>
  40e588:	83 f8 05             	cmp    $0x5,%eax
  40e58b:	0f 85 01 fe ff ff    	jne    40e392 <worker_thread+0xac2>
  40e591:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  40e596:	48 8d bc 24 e0 00 00 	lea    0xe0(%rsp),%rdi
  40e59d:	00 
  40e59e:	e8 bd 2b ff ff       	callq  401160 <gettimeofday@plt>
    printf("Intractable " FCS_B_AT_FMT "\n", board_num,
  40e5a3:	48 89 de             	mov    %rbx,%rsi
  40e5a6:	bf c0 13 41 00       	mov    $0x4113c0,%edi
  40e5ab:	31 c0                	xor    %eax,%eax
  40e5ad:	48 8b 8c 24 e8 00 00 	mov    0xe8(%rsp),%rcx
  40e5b4:	00 
  40e5b5:	48 8b 94 24 e0 00 00 	mov    0xe0(%rsp),%rdx
  40e5bc:	00 
  40e5bd:	e8 6e 2a ff ff       	callq  401030 <printf@plt>
  40e5c2:	e9 dd fd ff ff       	jmpq   40e3a4 <worker_thread+0xad4>
  40e5c7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40e5ce:	00 00 
                pthread_mutex_lock(&total_num_iters_lock);
  40e5d0:	bf 20 41 41 00       	mov    $0x414120,%edi
  40e5d5:	e8 76 2b ff ff       	callq  401150 <pthread_mutex_lock@plt>
                pthread_mutex_unlock(&total_num_iters_lock);
  40e5da:	bf 20 41 41 00       	mov    $0x414120,%edi
                total_num_iters += total_num_iters_temp;
  40e5df:	4c 01 3d 22 5b 00 00 	add    %r15,0x5b22(%rip)        # 414108 <total_num_iters>
                total_num_iters_temp = 0;
  40e5e6:	45 31 ff             	xor    %r15d,%r15d
                pthread_mutex_unlock(&total_num_iters_lock);
  40e5e9:	e8 d2 2a ff ff       	callq  4010c0 <pthread_mutex_unlock@plt>
                total_num_iters_temp = 0;
  40e5ee:	e9 e2 fd ff ff       	jmpq   40e3d5 <worker_thread+0xb05>
  40e5f3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e5fa:	00 00 00 00 
  40e5fe:	66 90                	xchg   %ax,%ax
    FCS_GET_TIME(ret);
  40e600:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  40e605:	48 8d bc 24 e0 00 00 	lea    0xe0(%rsp),%rdi
  40e60c:	00 
  40e60d:	e8 4e 2b ff ff       	callq  401160 <gettimeofday@plt>
    printf("Unsolved " FCS_B_AT_FMT "\n", board_num, FCS_TIME_GET_SEC(mytime),
  40e612:	48 89 de             	mov    %rbx,%rsi
  40e615:	bf f0 13 41 00       	mov    $0x4113f0,%edi
  40e61a:	31 c0                	xor    %eax,%eax
  40e61c:	48 8b 8c 24 e8 00 00 	mov    0xe8(%rsp),%rcx
  40e623:	00 
  40e624:	48 8b 94 24 e0 00 00 	mov    0xe0(%rsp),%rdx
  40e62b:	00 
  40e62c:	e8 ff 29 ff ff       	callq  401030 <printf@plt>
  40e631:	e9 6e fd ff ff       	jmpq   40e3a4 <worker_thread+0xad4>
  40e636:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40e63d:	00 00 00 
{
#ifdef FCS_WITH_ERROR_STRS
    fprintf(stderr, "Flares Plan: %s\n",
        freecell_solver_user_get_last_error_string(instance));
#else
    fprintf(stderr, "%s\n", "Flares Plan Error");
  40e640:	48 8b 3d 99 5a 00 00 	mov    0x5a99(%rip),%rdi        # 4140e0 <stderr@@GLIBC_2.2.5>
  40e647:	ba 68 f1 40 00       	mov    $0x40f168,%edx
  40e64c:	be 7a f1 40 00       	mov    $0x40f17a,%esi
  40e651:	31 c0                	xor    %eax,%eax
  40e653:	4d 89 ee             	mov    %r13,%r14
  40e656:	e8 e5 2a ff ff       	callq  401140 <fprintf@plt>
        if ((ret_code != FCS_STATE_NOT_BEGAN_YET) &&
  40e65b:	41 8b 86 b8 05 00 00 	mov    0x5b8(%r14),%eax
  40e662:	83 e8 08             	sub    $0x8,%eax
  40e665:	83 f8 01             	cmp    $0x1,%eax
  40e668:	76 0e                	jbe    40e678 <worker_thread+0xda8>
            (ret_code != FCS_STATE_INVALID_STATE) &&
  40e66a:	41 80 be bc 05 00 00 	cmpb   $0x0,0x5bc(%r14)
  40e671:	00 
  40e672:	0f 84 a8 04 00 00    	je     40eb20 <worker_thread+0x1250>
        if (st_idx < num_soft_threads)
  40e678:	48 c7 44 24 10 00 00 	movq   $0x0,0x10(%rsp)
  40e67f:	00 00 
    const int_fast32_t num_soft_threads =
  40e681:	49 8b 86 20 05 00 00 	mov    0x520(%r14),%rax
    for (int_fast32_t st_idx = 0; st_idx <= num_soft_threads; ++st_idx)
  40e688:	48 c7 44 24 20 00 00 	movq   $0x0,0x20(%rsp)
  40e68f:	00 00 
    const int_fast32_t num_soft_threads =
  40e691:	48 89 04 24          	mov    %rax,(%rsp)
        if (st_idx < num_soft_threads)
  40e695:	48 85 c0             	test   %rax,%rax
  40e698:	0f 8e b9 01 00 00    	jle    40e857 <worker_thread+0xf87>
  40e69e:	4c 89 74 24 08       	mov    %r14,0x8(%rsp)
  40e6a3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e6aa:	00 00 00 00 
  40e6ae:	66 90                	xchg   %ax,%ax
            soft_thread = &(instance->hard_thread.soft_threads[st_idx]);
  40e6b0:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  40e6b5:	4c 8b 64 24 10       	mov    0x10(%rsp),%r12
  40e6ba:	4c 03 a0 c0 00 00 00 	add    0xc0(%rax),%r12
    free(pq->elems);
  40e6c1:	49 8b bc 24 00 01 00 	mov    0x100(%r12),%rdi
  40e6c8:	00 
  40e6c9:	e8 82 29 ff ff       	callq  401050 <free@plt>
#include "move_funcs_order.h"

static inline void fcs_free_moves_list(fcs_soft_thread *const soft_thread)
{
    /* Free the BeFS data. */
    free(BEFS_M_VAR(soft_thread, moves_list));
  40e6ce:	49 8b bc 24 c8 00 00 	mov    0xc8(%r12),%rdi
  40e6d5:	00 
    pq->elems = NULL;
  40e6d6:	49 c7 84 24 00 01 00 	movq   $0x0,0x100(%r12)
  40e6dd:	00 00 00 00 00 
  40e6e2:	e8 69 29 ff ff       	callq  401050 <free@plt>
    BEFS_M_VAR(soft_thread, moves_list) = NULL;

    /* Free the DFS data. */
    fcs_moves_by_depth_array *const arr =
        &(DFS_VAR(soft_thread, moves_by_depth));
    const_SLOT(num_units, arr);
  40e6e7:	49 8b 44 24 50       	mov    0x50(%r12),%rax
    BEFS_M_VAR(soft_thread, moves_list) = NULL;
  40e6ec:	49 c7 84 24 c8 00 00 	movq   $0x0,0xc8(%r12)
  40e6f3:	00 00 00 00 00 
    const_SLOT(num_units, arr);
  40e6f8:	49 8b 7c 24 58       	mov    0x58(%r12),%rdi
  40e6fd:	48 89 44 24 28       	mov    %rax,0x28(%rsp)
    for (size_t unit_idx = 0; unit_idx < num_units; unit_idx++)
  40e702:	48 85 c0             	test   %rax,%rax
  40e705:	74 76                	je     40e77d <worker_thread+0xead>
  40e707:	45 31 f6             	xor    %r14d,%r14d
  40e70a:	eb 0f                	jmp    40e71b <worker_thread+0xe4b>
  40e70c:	0f 1f 40 00          	nopl   0x0(%rax)
  40e710:	49 83 c6 01          	add    $0x1,%r14
  40e714:	4c 39 74 24 28       	cmp    %r14,0x28(%rsp)
  40e719:	74 62                	je     40e77d <worker_thread+0xead>
    {
        if (arr->by_depth_units[unit_idx].move_funcs.groups)
  40e71b:	4b 8d 04 76          	lea    (%r14,%r14,2),%rax
  40e71f:	48 8d 14 c7          	lea    (%rdi,%rax,8),%rdx
  40e723:	4c 8b 7a 10          	mov    0x10(%rdx),%r15
  40e727:	4d 85 ff             	test   %r15,%r15
  40e72a:	74 e4                	je     40e710 <worker_thread+0xe40>
        {
            fcs_moves_group *const groups =
                arr->by_depth_units[unit_idx].move_funcs.groups;
            const_AUTO(num, arr->by_depth_units[unit_idx].move_funcs.num);
  40e72c:	48 8b 5a 08          	mov    0x8(%rdx),%rbx

            for (typeof(arr->by_depth_units[unit_idx].move_funcs.num) i = 0;
  40e730:	48 85 db             	test   %rbx,%rbx
  40e733:	74 30                	je     40e765 <worker_thread+0xe95>
  40e735:	48 69 db e8 00 00 00 	imul   $0xe8,%rbx,%rbx
  40e73c:	4d 89 fd             	mov    %r15,%r13
  40e73f:	4c 01 fb             	add    %r15,%rbx
  40e742:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e749:	00 00 00 00 
  40e74d:	0f 1f 00             	nopl   (%rax)
                 i < num; i++)
            {
                free(groups[i].move_funcs);
  40e750:	49 8b 7d 00          	mov    0x0(%r13),%rdi
  40e754:	49 81 c5 e8 00 00 00 	add    $0xe8,%r13
  40e75b:	e8 f0 28 ff ff       	callq  401050 <free@plt>
            for (typeof(arr->by_depth_units[unit_idx].move_funcs.num) i = 0;
  40e760:	4c 39 eb             	cmp    %r13,%rbx
  40e763:	75 eb                	jne    40e750 <worker_thread+0xe80>
            }
            free(groups);
  40e765:	4c 89 ff             	mov    %r15,%rdi
    for (size_t unit_idx = 0; unit_idx < num_units; unit_idx++)
  40e768:	49 83 c6 01          	add    $0x1,%r14
            free(groups);
  40e76c:	e8 df 28 ff ff       	callq  401050 <free@plt>
  40e771:	49 8b 7c 24 58       	mov    0x58(%r12),%rdi
    for (size_t unit_idx = 0; unit_idx < num_units; unit_idx++)
  40e776:	4c 39 74 24 28       	cmp    %r14,0x28(%rsp)
  40e77b:	75 9e                	jne    40e71b <worker_thread+0xe4b>
        }
    }
    free(arr->by_depth_units);
  40e77d:	e8 ce 28 ff ff       	callq  401050 <free@plt>
    const_AUTO(
  40e782:	49 8b 44 24 18       	mov    0x18(%r12),%rax
    arr->by_depth_units = NULL;
  40e787:	49 c7 44 24 58 00 00 	movq   $0x0,0x58(%r12)
  40e78e:	00 00 
    const_AUTO(num, soft_thread->by_depth_moves_order.num);
  40e790:	49 8b 54 24 10       	mov    0x10(%r12),%rdx
    const_AUTO(
  40e795:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
    for (size_t i = 0; i < num; ++i)
  40e79a:	48 85 d2             	test   %rdx,%rdx
  40e79d:	74 79                	je     40e818 <worker_thread+0xf48>
  40e79f:	48 8d 14 52          	lea    (%rdx,%rdx,2),%rdx
  40e7a3:	4c 8d 78 08          	lea    0x8(%rax),%r15
  40e7a7:	48 8d 44 d0 08       	lea    0x8(%rax,%rdx,8),%rax
  40e7ac:	48 89 44 24 28       	mov    %rax,0x28(%rsp)
  40e7b1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e7b8:	00 00 00 00 
  40e7bc:	0f 1f 40 00          	nopl   0x0(%rax)
    const_SLOT(num, moves_order);
  40e7c0:	49 8b 1f             	mov    (%r15),%rbx
    const_SLOT(groups, moves_order);
  40e7c3:	4d 8b 77 08          	mov    0x8(%r15),%r14
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40e7c7:	48 85 db             	test   %rbx,%rbx
  40e7ca:	74 29                	je     40e7f5 <worker_thread+0xf25>
  40e7cc:	48 69 db e8 00 00 00 	imul   $0xe8,%rbx,%rbx
  40e7d3:	4d 89 f5             	mov    %r14,%r13
  40e7d6:	4c 01 f3             	add    %r14,%rbx
  40e7d9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        free(groups[group_idx].move_funcs);
  40e7e0:	49 8b 7d 00          	mov    0x0(%r13),%rdi
  40e7e4:	49 81 c5 e8 00 00 00 	add    $0xe8,%r13
  40e7eb:	e8 60 28 ff ff       	callq  401050 <free@plt>
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40e7f0:	4c 39 eb             	cmp    %r13,%rbx
  40e7f3:	75 eb                	jne    40e7e0 <worker_thread+0xf10>
    free(groups);
  40e7f5:	4c 89 f7             	mov    %r14,%rdi
  40e7f8:	49 83 c7 18          	add    $0x18,%r15
  40e7fc:	e8 4f 28 ff ff       	callq  401050 <free@plt>
    moves_order->groups = NULL;
  40e801:	49 c7 47 f0 00 00 00 	movq   $0x0,-0x10(%r15)
  40e808:	00 
    moves_order->num = 0;
  40e809:	49 c7 47 e8 00 00 00 	movq   $0x0,-0x18(%r15)
  40e810:	00 
  40e811:	4c 3b 7c 24 28       	cmp    0x28(%rsp),%r15
  40e816:	75 a8                	jne    40e7c0 <worker_thread+0xef0>
    soft_thread->by_depth_moves_order.num = 0;
  40e818:	49 c7 44 24 10 00 00 	movq   $0x0,0x10(%r12)
  40e81f:	00 00 
    free(by_depth_moves);
  40e821:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  40e826:	e8 25 28 ff ff       	callq  401050 <free@plt>
    soft_thread->by_depth_moves_order.by_depth_moves = NULL;
  40e82b:	49 c7 44 24 18 00 00 	movq   $0x0,0x18(%r12)
  40e832:	00 00 
    for (int_fast32_t st_idx = 0; st_idx <= num_soft_threads; ++st_idx)
  40e834:	48 83 44 24 20 01    	addq   $0x1,0x20(%rsp)
  40e83a:	48 81 44 24 10 f8 01 	addq   $0x1f8,0x10(%rsp)
  40e841:	00 00 
  40e843:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
        if (st_idx < num_soft_threads)
  40e848:	48 39 04 24          	cmp    %rax,(%rsp)
  40e84c:	0f 85 5e fe ff ff    	jne    40e6b0 <worker_thread+0xde0>
  40e852:	4c 8b 74 24 08       	mov    0x8(%rsp),%r14
    free(HT_FIELD(hard_thread, soft_threads));
  40e857:	49 8b be c0 00 00 00 	mov    0xc0(%r14),%rdi
  40e85e:	e8 ed 27 ff ff       	callq  401050 <free@plt>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e863:	49 8b 96 d8 00 00 00 	mov    0xd8(%r14),%rdx
    meta_allocator *const meta = allocator->meta;
  40e86a:	49 8b be f8 00 00 00 	mov    0xf8(%r14),%rdi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e871:	48 8b 02             	mov    (%rdx),%rax
    var_AUTO(bin, meta->recycle_bin);
  40e874:	48 8b 37             	mov    (%rdi),%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e877:	48 85 c0             	test   %rax,%rax
  40e87a:	75 1a                	jne    40e896 <worker_thread+0xfc6>
  40e87c:	e9 71 03 00 00       	jmpq   40ebf2 <worker_thread+0x1322>
  40e881:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e888:	00 00 00 00 
  40e88c:	0f 1f 40 00          	nopl   0x0(%rax)
  40e890:	48 89 c2             	mov    %rax,%rdx
  40e893:	48 89 c8             	mov    %rcx,%rax
        OLD_LIST_NEXT(iter) = bin;
  40e896:	48 89 32             	mov    %rsi,(%rdx)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  40e899:	48 8b 08             	mov    (%rax),%rcx
  40e89c:	48 89 d6             	mov    %rdx,%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e89f:	48 85 c9             	test   %rcx,%rcx
  40e8a2:	75 ec                	jne    40e890 <worker_thread+0xfc0>
    const_SLOT(num, moves_order);
  40e8a4:	4d 8b a6 30 05 00 00 	mov    0x530(%r14),%r12
    OLD_LIST_NEXT(iter) = bin;
  40e8ab:	48 89 10             	mov    %rdx,(%rax)
    const_SLOT(groups, moves_order);
  40e8ae:	4d 8b ae 38 05 00 00 	mov    0x538(%r14),%r13
    meta->recycle_bin = iter;
  40e8b5:	48 89 07             	mov    %rax,(%rdi)
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40e8b8:	4d 85 e4             	test   %r12,%r12
  40e8bb:	74 27                	je     40e8e4 <worker_thread+0x1014>
  40e8bd:	4d 69 e4 e8 00 00 00 	imul   $0xe8,%r12,%r12
  40e8c4:	4c 89 eb             	mov    %r13,%rbx
  40e8c7:	4d 01 ec             	add    %r13,%r12
  40e8ca:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        free(groups[group_idx].move_funcs);
  40e8d0:	48 8b 3b             	mov    (%rbx),%rdi
  40e8d3:	48 81 c3 e8 00 00 00 	add    $0xe8,%rbx
  40e8da:	e8 71 27 ff ff       	callq  401050 <free@plt>
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40e8df:	49 39 dc             	cmp    %rbx,%r12
  40e8e2:	75 ec                	jne    40e8d0 <worker_thread+0x1000>
    free(groups);
  40e8e4:	4c 89 ef             	mov    %r13,%rdi
        iter_next = iter ? OLD_LIST_NEXT(iter) : NULL;
  40e8e7:	31 db                	xor    %ebx,%ebx
  40e8e9:	e8 62 27 ff ff       	callq  401050 <free@plt>
    for (iter = meta_alloc->recycle_bin,
  40e8ee:	49 8b be 48 12 00 00 	mov    0x1248(%r14),%rdi
    moves_order->groups = NULL;
  40e8f5:	49 c7 86 38 05 00 00 	movq   $0x0,0x538(%r14)
  40e8fc:	00 00 00 00 
    moves_order->num = 0;
  40e900:	49 c7 86 30 05 00 00 	movq   $0x0,0x530(%r14)
  40e907:	00 00 00 00 
        iter_next = iter ? OLD_LIST_NEXT(iter) : NULL;
  40e90b:	48 85 ff             	test   %rdi,%rdi
  40e90e:	74 23                	je     40e933 <worker_thread+0x1063>
  40e910:	48 8b 1f             	mov    (%rdi),%rbx
    for (iter = meta_alloc->recycle_bin,
  40e913:	48 85 db             	test   %rbx,%rbx
  40e916:	75 0b                	jne    40e923 <worker_thread+0x1053>
  40e918:	e9 ea 02 00 00       	jmpq   40ec07 <worker_thread+0x1337>
  40e91d:	0f 1f 00             	nopl   (%rax)
  40e920:	48 89 c3             	mov    %rax,%rbx
        free(iter);
  40e923:	e8 28 27 ff ff       	callq  401050 <free@plt>
         iter_next; iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  40e928:	48 8b 03             	mov    (%rbx),%rax
  40e92b:	48 89 df             	mov    %rbx,%rdi
    for (iter = meta_alloc->recycle_bin,
  40e92e:	48 85 c0             	test   %rax,%rax
  40e931:	75 ed                	jne    40e920 <worker_thread+0x1050>
    free(iter);
  40e933:	48 89 df             	mov    %rbx,%rdi
  40e936:	e8 15 27 ff ff       	callq  401050 <free@plt>
    free(user);
  40e93b:	4c 89 f7             	mov    %r14,%rdi
  40e93e:	e8 0d 27 ff ff       	callq  401050 <free@plt>
}
  40e943:	48 8d 65 d8          	lea    -0x28(%rbp),%rsp
  40e947:	31 c0                	xor    %eax,%eax
  40e949:	5b                   	pop    %rbx
  40e94a:	41 5c                	pop    %r12
  40e94c:	41 5d                	pop    %r13
  40e94e:	41 5e                	pop    %r14
  40e950:	41 5f                	pop    %r15
  40e952:	5d                   	pop    %rbp
  40e953:	c3                   	retq   
  40e954:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e95b:	00 00 00 00 
  40e95f:	90                   	nop
    fc_solve_finish_instance(instance);
  40e960:	4c 89 ef             	mov    %r13,%rdi
  40e963:	e8 e8 2e ff ff       	callq  401850 <fc_solve_finish_instance>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e968:	49 8b 95 d8 00 00 00 	mov    0xd8(%r13),%rdx
    HT_FIELD(hard_thread, ht__max_num_checked_states) = FCS_INT_LIMIT_MAX;
  40e96f:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  40e976:	ff ff 7f 
    instance->i__num_checked_states = 0;
  40e979:	49 c7 45 00 00 00 00 	movq   $0x0,0x0(%r13)
  40e980:	00 
  40e981:	49 89 85 c8 00 00 00 	mov    %rax,0xc8(%r13)
    meta_allocator *const meta = allocator->meta;
  40e988:	49 8b bd f8 00 00 00 	mov    0xf8(%r13),%rdi
    instance->num_hard_threads_finished = 0;
  40e98f:	49 c7 85 40 05 00 00 	movq   $0x0,0x540(%r13)
  40e996:	00 00 00 00 
    HT_FIELD(hard_thread, num_soft_threads_finished) = 0;
  40e99a:	41 c7 85 28 05 00 00 	movl   $0x0,0x528(%r13)
  40e9a1:	00 00 00 00 
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e9a5:	48 8b 02             	mov    (%rdx),%rax
    var_AUTO(bin, meta->recycle_bin);
  40e9a8:	48 8b 37             	mov    (%rdi),%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e9ab:	48 85 c0             	test   %rax,%rax
  40e9ae:	75 16                	jne    40e9c6 <worker_thread+0x10f6>
  40e9b0:	e9 5b 01 00 00       	jmpq   40eb10 <worker_thread+0x1240>
  40e9b5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e9bc:	00 00 00 00 
  40e9c0:	48 89 c2             	mov    %rax,%rdx
  40e9c3:	48 89 c8             	mov    %rcx,%rax
        OLD_LIST_NEXT(iter) = bin;
  40e9c6:	48 89 32             	mov    %rsi,(%rdx)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  40e9c9:	48 8b 08             	mov    (%rax),%rcx
  40e9cc:	48 89 d6             	mov    %rdx,%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e9cf:	48 85 c9             	test   %rcx,%rcx
  40e9d2:	75 ec                	jne    40e9c0 <worker_thread+0x10f0>
    OLD_LIST_NEXT(iter) = bin;
  40e9d4:	48 89 10             	mov    %rdx,(%rax)
    meta->recycle_bin = iter;
  40e9d7:	48 89 07             	mov    %rax,(%rdi)
  40e9da:	49 c7 85 d8 00 00 00 	movq   $0x0,0xd8(%r13)
  40e9e1:	00 00 00 00 
    char *const ret = meta_alloc->recycle_bin;
  40e9e5:	48 8b 07             	mov    (%rdi),%rax
    if (ret)
  40e9e8:	48 85 c0             	test   %rax,%rax
  40e9eb:	0f 84 ff 00 00 00    	je     40eaf0 <worker_thread+0x1220>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40e9f1:	48 8b 10             	mov    (%rax),%rdx
  40e9f4:	48 89 17             	mov    %rdx,(%rdi)
        return ret;
  40e9f7:	49 8b 95 d8 00 00 00 	mov    0xd8(%r13),%rdx
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40e9fe:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40ea01:	48 8d 50 08          	lea    0x8(%rax),%rdx
    ST_LOOP_START()
  40ea05:	4d 8b b5 c0 00 00 00 	mov    0xc0(%r13),%r14
    allocator->old_list = new_data;
  40ea0c:	49 89 85 d8 00 00 00 	mov    %rax,0xd8(%r13)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40ea13:	48 05 80 fe 00 00    	add    $0xfe80,%rax
  40ea19:	49 89 85 e0 00 00 00 	mov    %rax,0xe0(%r13)
  40ea20:	49 69 85 20 05 00 00 	imul   $0x1f8,0x520(%r13),%rax
  40ea27:	f8 01 00 00 
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40ea2b:	49 89 95 f0 00 00 00 	mov    %rdx,0xf0(%r13)
  40ea32:	49 89 95 e8 00 00 00 	mov    %rdx,0xe8(%r13)
  40ea39:	4c 01 f0             	add    %r14,%rax
  40ea3c:	49 39 c6             	cmp    %rax,%r14
  40ea3f:	73 3f                	jae    40ea80 <worker_thread+0x11b0>
  40ea41:	48 89 5c 24 10       	mov    %rbx,0x10(%rsp)
  40ea46:	4c 89 f3             	mov    %r14,%rbx
  40ea49:	49 89 c6             	mov    %rax,%r14
  40ea4c:	0f 1f 40 00          	nopl   0x0(%rax)
    free(pq->elems);
  40ea50:	48 8b bb 00 01 00 00 	mov    0x100(%rbx),%rdi
  40ea57:	48 81 c3 f8 01 00 00 	add    $0x1f8,%rbx
  40ea5e:	e8 ed 25 ff ff       	callq  401050 <free@plt>
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED);
  40ea63:	c6 43 e8 00          	movb   $0x0,-0x18(%rbx)
    pq->elems = NULL;
  40ea67:	48 c7 83 08 ff ff ff 	movq   $0x0,-0xf8(%rbx)
  40ea6e:	00 00 00 00 
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED);
  40ea72:	c6 43 e9 00          	movb   $0x0,-0x17(%rbx)
  40ea76:	49 39 de             	cmp    %rbx,%r14
  40ea79:	77 d5                	ja     40ea50 <worker_thread+0x1180>
  40ea7b:	48 8b 5c 24 10       	mov    0x10(%rsp),%rbx
        flare->instance_is_ready = TRUE;
  40ea80:	41 c6 85 bc 05 00 00 	movb   $0x1,0x5bc(%r13)
  40ea87:	01 
  40ea88:	e9 75 f9 ff ff       	jmpq   40e402 <worker_thread+0xb32>
  40ea8d:	0f 1f 00             	nopl   (%rax)
                pthread_mutex_lock(&total_num_iters_lock);
  40ea90:	bf 20 41 41 00       	mov    $0x414120,%edi
  40ea95:	e8 b6 26 ff ff       	callq  401150 <pthread_mutex_lock@plt>
                    (total_num_iters += total_num_iters_temp);
  40ea9a:	4c 03 3d 67 56 00 00 	add    0x5667(%rip),%r15        # 414108 <total_num_iters>
                pthread_mutex_unlock(&total_num_iters_lock);
  40eaa1:	bf 20 41 41 00       	mov    $0x414120,%edi
                    (total_num_iters += total_num_iters_temp);
  40eaa6:	4c 89 3d 5b 56 00 00 	mov    %r15,0x565b(%rip)        # 414108 <total_num_iters>
                pthread_mutex_unlock(&total_num_iters_lock);
  40eaad:	e8 0e 26 ff ff       	callq  4010c0 <pthread_mutex_unlock@plt>
    FCS_GET_TIME(ret);
  40eab2:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  40eab7:	48 8d bc 24 e0 00 00 	lea    0xe0(%rsp),%rdi
  40eabe:	00 
  40eabf:	e8 9c 26 ff ff       	callq  401160 <gettimeofday@plt>
    printf("Reached " FCS_B_AT_FMT " (total_num_iters=" FCS_LL_FMT ")\n",
  40eac4:	4d 89 f8             	mov    %r15,%r8
  40eac7:	48 89 de             	mov    %rbx,%rsi
  40eaca:	bf 18 14 41 00       	mov    $0x411418,%edi
  40eacf:	48 8b 8c 24 e8 00 00 	mov    0xe8(%rsp),%rcx
  40ead6:	00 
  40ead7:	31 c0                	xor    %eax,%eax
                total_num_iters_temp = 0;
  40ead9:	45 31 ff             	xor    %r15d,%r15d
  40eadc:	48 8b 94 24 e0 00 00 	mov    0xe0(%rsp),%rdx
  40eae3:	00 
  40eae4:	e8 47 25 ff ff       	callq  401030 <printf@plt>
  40eae9:	e9 fc f8 ff ff       	jmpq   40e3ea <worker_thread+0xb1a>
  40eaee:	66 90                	xchg   %ax,%ax
        return malloc(ALLOCED_SIZE);
  40eaf0:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40eaf5:	e8 f6 25 ff ff       	callq  4010f0 <malloc@plt>
  40eafa:	31 d2                	xor    %edx,%edx
  40eafc:	e9 fd fe ff ff       	jmpq   40e9fe <worker_thread+0x112e>
  40eb01:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40eb08:	00 00 00 00 
  40eb0c:	0f 1f 40 00          	nopl   0x0(%rax)
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40eb10:	48 89 d0             	mov    %rdx,%rax
    var_AUTO(bin, meta->recycle_bin);
  40eb13:	48 89 f2             	mov    %rsi,%rdx
  40eb16:	e9 b9 fe ff ff       	jmpq   40e9d4 <worker_thread+0x1104>
  40eb1b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            fc_solve_finish_instance(instance);
  40eb20:	4c 89 f7             	mov    %r14,%rdi
  40eb23:	e8 28 2d ff ff       	callq  401850 <fc_solve_finish_instance>
  40eb28:	e9 4b fb ff ff       	jmpq   40e678 <worker_thread+0xda8>
  40eb2d:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40eb34:	e9 d2 f4 ff ff       	jmpq   40e00b <worker_thread+0x73b>
  40eb39:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40eb40:	e9 13 f4 ff ff       	jmpq   40df58 <worker_thread+0x688>
  40eb45:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40eb4c:	e9 7d f4 ff ff       	jmpq   40dfce <worker_thread+0x6fe>
  40eb51:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40eb58:	e9 26 ef ff ff       	jmpq   40da83 <worker_thread+0x1b3>
  40eb5d:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40eb64:	e9 7a ef ff ff       	jmpq   40dae3 <worker_thread+0x213>
  40eb69:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40eb70:	e9 c3 ef ff ff       	jmpq   40db38 <worker_thread+0x268>
  40eb75:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40eb7c:	e9 77 f3 ff ff       	jmpq   40def8 <worker_thread+0x628>
  40eb81:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40eb88:	e9 24 f0 ff ff       	jmpq   40dbb1 <worker_thread+0x2e1>
  40eb8d:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40eb94:	e9 7f f0 ff ff       	jmpq   40dc18 <worker_thread+0x348>
  40eb99:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40eba0:	e9 ec f0 ff ff       	jmpq   40dc91 <worker_thread+0x3c1>
  40eba5:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40ebac:	e9 59 f1 ff ff       	jmpq   40dd0a <worker_thread+0x43a>
  40ebb1:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40ebb8:	e9 bf f1 ff ff       	jmpq   40dd7c <worker_thread+0x4ac>
  40ebbd:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40ebc4:	e9 01 f2 ff ff       	jmpq   40ddca <worker_thread+0x4fa>
  40ebc9:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40ebd0:	e9 67 f2 ff ff       	jmpq   40de3c <worker_thread+0x56c>
  40ebd5:	49 8b 86 40 06 00 00 	mov    0x640(%r14),%rax
  40ebdc:	e9 c2 f2 ff ff       	jmpq   40dea3 <worker_thread+0x5d3>
        return malloc(ALLOCED_SIZE);
  40ebe1:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40ebe6:	e8 05 25 ff ff       	callq  4010f0 <malloc@plt>
  40ebeb:	31 d2                	xor    %edx,%edx
  40ebed:	e9 d1 ed ff ff       	jmpq   40d9c3 <worker_thread+0xf3>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40ebf2:	48 89 d0             	mov    %rdx,%rax
    var_AUTO(bin, meta->recycle_bin);
  40ebf5:	48 89 f2             	mov    %rsi,%rdx
  40ebf8:	e9 a7 fc ff ff       	jmpq   40e8a4 <worker_thread+0xfd4>
        for (; board_num < quota_end; board_num++)
  40ebfd:	48 89 5c 24 28       	mov    %rbx,0x28(%rsp)
  40ec02:	e9 34 f8 ff ff       	jmpq   40e43b <worker_thread+0xb6b>
    for (iter = meta_alloc->recycle_bin,
  40ec07:	48 89 fb             	mov    %rdi,%rbx
  40ec0a:	e9 24 fd ff ff       	jmpq   40e933 <worker_thread+0x1063>
  40ec0f:	90                   	nop

000000000040ec10 <fc_solve_err>:
#include <stdlib.h>

static inline __attribute__((noreturn))
__attribute__((format(printf, 1, 2))) void
fc_solve_err(const char *msg, ...)
{
  40ec10:	48 81 ec d8 00 00 00 	sub    $0xd8,%rsp
  40ec17:	48 89 74 24 28       	mov    %rsi,0x28(%rsp)
  40ec1c:	48 89 54 24 30       	mov    %rdx,0x30(%rsp)
  40ec21:	48 89 4c 24 38       	mov    %rcx,0x38(%rsp)
  40ec26:	4c 89 44 24 40       	mov    %r8,0x40(%rsp)
  40ec2b:	4c 89 4c 24 48       	mov    %r9,0x48(%rsp)
  40ec30:	84 c0                	test   %al,%al
  40ec32:	74 3f                	je     40ec73 <fc_solve_err+0x63>
  40ec34:	c5 f8 29 44 24 50    	vmovaps %xmm0,0x50(%rsp)
  40ec3a:	c5 f8 29 4c 24 60    	vmovaps %xmm1,0x60(%rsp)
  40ec40:	c5 f8 29 54 24 70    	vmovaps %xmm2,0x70(%rsp)
  40ec46:	c5 f8 29 9c 24 80 00 	vmovaps %xmm3,0x80(%rsp)
  40ec4d:	00 00 
  40ec4f:	c5 f8 29 a4 24 90 00 	vmovaps %xmm4,0x90(%rsp)
  40ec56:	00 00 
  40ec58:	c5 f8 29 ac 24 a0 00 	vmovaps %xmm5,0xa0(%rsp)
  40ec5f:	00 00 
  40ec61:	c5 f8 29 b4 24 b0 00 	vmovaps %xmm6,0xb0(%rsp)
  40ec68:	00 00 
  40ec6a:	c5 f8 29 bc 24 c0 00 	vmovaps %xmm7,0xc0(%rsp)
  40ec71:	00 00 
    va_list ap;

    va_start(ap, msg);
    vfprintf(stderr, msg, ap);
  40ec73:	48 89 fe             	mov    %rdi,%rsi
  40ec76:	48 8b 3d 63 54 00 00 	mov    0x5463(%rip),%rdi        # 4140e0 <stderr@@GLIBC_2.2.5>
  40ec7d:	48 89 e2             	mov    %rsp,%rdx
    va_start(ap, msg);
  40ec80:	c7 04 24 08 00 00 00 	movl   $0x8,(%rsp)
  40ec87:	48 8d 84 24 e0 00 00 	lea    0xe0(%rsp),%rax
  40ec8e:	00 
  40ec8f:	c7 44 24 04 30 00 00 	movl   $0x30,0x4(%rsp)
  40ec96:	00 
  40ec97:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  40ec9c:	48 8d 44 24 20       	lea    0x20(%rsp),%rax
  40eca1:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
    vfprintf(stderr, msg, ap);
  40eca6:	e8 75 24 ff ff       	callq  401120 <vfprintf@plt>
    va_end(ap);
    exit(-1);
  40ecab:	bf ff ff ff ff       	mov    $0xffffffff,%edi
  40ecb0:	e8 5b 24 ff ff       	callq  401110 <exit@plt>
  40ecb5:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40ecbc:	00 00 00 
  40ecbf:	90                   	nop

000000000040ecc0 <__libc_csu_init>:
  40ecc0:	41 57                	push   %r15
  40ecc2:	49 89 d7             	mov    %rdx,%r15
  40ecc5:	41 56                	push   %r14
  40ecc7:	49 89 f6             	mov    %rsi,%r14
  40ecca:	41 55                	push   %r13
  40eccc:	41 89 fd             	mov    %edi,%r13d
  40eccf:	41 54                	push   %r12
  40ecd1:	4c 8d 25 f8 50 00 00 	lea    0x50f8(%rip),%r12        # 413dd0 <__frame_dummy_init_array_entry>
  40ecd8:	55                   	push   %rbp
  40ecd9:	48 8d 2d f8 50 00 00 	lea    0x50f8(%rip),%rbp        # 413dd8 <__init_array_end>
  40ece0:	53                   	push   %rbx
  40ece1:	4c 29 e5             	sub    %r12,%rbp
  40ece4:	48 83 ec 08          	sub    $0x8,%rsp
  40ece8:	e8 13 23 ff ff       	callq  401000 <_init>
  40eced:	48 c1 fd 03          	sar    $0x3,%rbp
  40ecf1:	74 1b                	je     40ed0e <__libc_csu_init+0x4e>
  40ecf3:	31 db                	xor    %ebx,%ebx
  40ecf5:	0f 1f 00             	nopl   (%rax)
  40ecf8:	4c 89 fa             	mov    %r15,%rdx
  40ecfb:	4c 89 f6             	mov    %r14,%rsi
  40ecfe:	44 89 ef             	mov    %r13d,%edi
  40ed01:	41 ff 14 dc          	callq  *(%r12,%rbx,8)
  40ed05:	48 83 c3 01          	add    $0x1,%rbx
  40ed09:	48 39 dd             	cmp    %rbx,%rbp
  40ed0c:	75 ea                	jne    40ecf8 <__libc_csu_init+0x38>
  40ed0e:	48 83 c4 08          	add    $0x8,%rsp
  40ed12:	5b                   	pop    %rbx
  40ed13:	5d                   	pop    %rbp
  40ed14:	41 5c                	pop    %r12
  40ed16:	41 5d                	pop    %r13
  40ed18:	41 5e                	pop    %r14
  40ed1a:	41 5f                	pop    %r15
  40ed1c:	c3                   	retq   
  40ed1d:	0f 1f 00             	nopl   (%rax)

000000000040ed20 <__libc_csu_fini>:
  40ed20:	c3                   	retq   

Disassembly of section .fini:

000000000040ed24 <_fini>:
  40ed24:	48 83 ec 08          	sub    $0x8,%rsp
  40ed28:	48 83 c4 08          	add    $0x8,%rsp
  40ed2c:	c3                   	retq   
